julIDE

A modern, fully-featured IDE for the Julia programming language, built with Tauri 2, React, TypeScript, and Rust.

Credits

@ Rakesh - conributed multiple bug fixs and featue suggestions 🎉

@ RockyBeast - contributed the new julIDE icons 🎉

Features

Code Editing

• Monaco Editor with full Julia syntax highlighting via a custom Monarch tokenizer
• 25+ Julia snippets — function, struct, try/catch, @testset, comprehensions, macros, and more
• Tabbed multi-file editing with dirty indicators and auto-save
• Split editor — side-by-side editing with a resizable divider
• Breadcrumb navigation showing the file path below the tab bar
• Find & Replace (Cmd/Ctrl+F, Cmd/Ctrl+H) via Monaco's built-in widget
• Configurable font size, font family, tab size, word wrap, and minimap
• LaTeX to Unicode — type \alpha + Tab to insert α (based on Julia's LaTeX symbols table)

Language Intelligence (LSP)

• Powered by LanguageServer.jl
• Autocompletion, hover documentation, go-to-definition, find references
• Signature help with parameter info
• Real-time diagnostics (errors and warnings) shown inline and in the Problems panel
• Error lens — inline diagnostic messages displayed at the end of each line
• InlayHints — type and parameter hints displayed inline in the editor
• Semantic tokens — rich semantic highlighting beyond syntax-level tokenization
• Workspace and document symbol search

Julia Runtime

• Run scripts with rich output — inline images (PNG, JPEG, SVG), HTML, and plain text
• Interactive REPL via xterm.js with full PTY emulation
• Multi-terminal support — create, switch, and close multiple Julia REPL sessions
• Debugger integration via Debugger.jl — breakpoints, step-through, variable inspection, call stack
• Code cell execution — ## markers create code cells; Ctrl/Cmd+Enter runs the current cell with inline results
• Variable Explorer — workspace variable introspection via the REPL with DataFrame viewer support
• Revise.jl toggle for hot-reload development
• Pluto.jl reactive notebook support — open .jl files as Pluto notebooks in a native window
• Package Manager — add and remove packages via Pkg.jl directly from the UI
• Environment selector — switch between Julia project environments

File Management

• File explorer with tree view, create/rename/delete files and folders
• Drag-and-drop to move files between directories
• File watching — automatically detects external changes (git, other editors) and refreshes the tree
• Quick Open (Cmd/Ctrl+P) — fuzzy file finder across the entire workspace
• Global Search (Cmd/Ctrl+Shift+F) — search across all files with regex, case-sensitivity, and glob filters

Git Integration

• Source control panel — view staged, unstaged, and untracked files
• Stage / unstage individual files or stage all at once
• Commit with a message directly from the UI
• Branch management — create, delete, and switch branches from the UI
• Push / Pull / Fetch — sync with remote repositories
• Merge — fast-forward and normal merges with conflict detection
• Stash — save, list, and pop stashed changes
• Ahead/Behind tracking — see how far your branch is from the upstream
• GitHub / GitLab / Gitea provider integration — browse PRs, issues, and CI status directly in the IDE
• Auth settings — store personal access tokens securely via the OS keychain
• Git blame — toggle inline blame annotations showing author, date, and commit summary per line
• Diff viewer — side-by-side diff view using Monaco DiffEditor
• Merge conflict resolution — detects conflict markers and provides "Accept Current", "Accept Incoming", and "Accept Both" action buttons inline
• Powered by libgit2 (via the git2 Rust crate) — no shell dependency for core operations

Workspace & UI

• Activity bar — switch between Explorer, Outline, Search, Variables, Source Control, and Dev Containers views
• Command palette (Cmd/Ctrl+Shift+P) with 35+ commands
• Settings panel (Cmd/Ctrl+,) — configure editor, terminal, and appearance
• Theme support — Dark and Light themes with full CSS variable system
• Welcome screen with recent projects on startup
• Resizable panels — sidebar and bottom panel with drag handles
• Outline panel — LSP-powered document symbol tree in the sidebar (functions, structs, modules, etc.)
• Variable Explorer — workspace variable introspection in the sidebar with DataFrame viewer
• Plot Pane — image gallery in the bottom panel for plot output (PNG, JPEG, SVG, HTML)
• Test Runner — runs Pkg.test() and parses @testset results in the bottom panel
• Status bar — Julia version, environment, git branch, LSP status, Revise/Pluto indicators

Dev Container Support

• Auto-detect devcontainer.json in the workspace and offer to build/start
• Docker and Podman runtime auto-detection (with manual override in settings)
• Build, start, stop, rebuild, and tear down dev containers from the UI or command palette
• Container panel in the sidebar — list running containers and images, start/stop/restart/remove
• Container logs panel — stream and view container output in real time
• Container terminal — open a PTY session inside the running container
• Run Julia inside the container — execute scripts in the dev container environment

Plugin System

• Plugin discovery — automatically scans ~/.julide/plugins/ for installed plugins
• Plugin manifest (plugin.json) — declare name, version, entry point, and contributions
• Plugin API — register commands, sidebar panels, bottom panels, status bar items, and toolbar buttons
• Plugin panel in the activity bar sidebar — view installed plugins and their status

Prerequisites

• Julia 1.6 or later (download)
• Rust (latest stable) — install via rustup
• Bun — install (used as the package manager and script runner)
• System dependencies for Tauri — see Tauri prerequisites

Recommended Julia packages

Install these globally for the best experience:

using Pkg
Pkg.add("LanguageServer")  # LSP support
Pkg.add("Revise")          # Hot-reload
Pkg.add("Debugger")        # Debugger integration
Pkg.add("Pluto")           # Reactive notebooks

Getting Started

Clone and install

git clone https://github.com/sinisterMage/JulIde.git
cd JulIde
bun install

Development

# Start the Tauri dev server (frontend + native window with hot reload)
bun run tauri dev

This starts Vite on localhost:1420 and opens the native Tauri window. Changes to both the React frontend and Rust backend are hot-reloaded.

Production Build

# Build the distributable application
bun run tauri build

The output is placed in src-tauri/target/release/bundle/ and includes platform-specific installers (.dmg on macOS, .msi/.exe on Windows, .deb/.AppImage on Linux).

Architecture

julIDE
├── src/                        # React + TypeScript frontend
│   ├── components/             # UI components
│   │   ├── ActivityBar/        # Sidebar view switcher
│   │   ├── CommandPalette/     # Cmd+Shift+P command search
│   │   ├── Debugger/           # Debug panel (variables, call stack)
│   │   ├── Editor/             # Monaco editor, tabs, breadcrumb, split view
│   │   ├── FileExplorer/       # File tree with drag-and-drop
│   │   ├── Container/           # Dev container management panel and logs
│   │   ├── Git/                # Source control panel, diff viewer
│   │   ├── Outline/            # LSP document symbol outline
│   │   ├── OutputPanel/        # Script output with MIME rendering
│   │   ├── PackageManager/     # Julia package management UI
│   │   ├── PlotPane/           # Plot output gallery
│   │   ├── Plugin/             # Plugin management panel
│   │   ├── QuickOpen/          # Fuzzy file finder (Cmd+P)
│   │   ├── SearchPanel/        # Global file search (Cmd+Shift+F)
│   │   ├── Settings/           # Preferences panel
│   │   ├── StatusBar/          # Bottom status indicators
│   │   ├── Terminal/           # Multi-terminal with xterm.js
│   │   ├── TestRunner/         # Test execution with result parsing
│   │   ├── Toolbar/            # Run, debug, Revise, Pluto buttons
│   │   ├── Variables/          # Variable explorer with DataFrame viewer
│   │   └── Welcome/            # Welcome screen with recent projects
│   ├── lsp/                    # LSP client and Monaco providers
│   ├── services/               # Keybinding service, plugin host, builtin contributions
│   ├── stores/                 # Zustand state management
│   ├── themes/                 # Theme definitions (dark + light)
│   ├── types/                  # TypeScript interfaces
│   └── App.tsx                 # Root layout component
│
├── src-tauri/                  # Rust backend (Tauri 2)
│   └── src/
│       ├── main.rs             # Entry point
│       ├── lib.rs              # Command registry and plugin setup
│       ├── julia.rs            # Julia discovery, execution, Pkg commands
│       ├── lsp.rs              # LanguageServer.jl JSON-RPC bridge
│       ├── pty.rs              # PTY terminal management
│       ├── debugger.rs         # Debugger.jl integration
│       ├── fs.rs               # File system operations and dialogs
│       ├── git.rs              # Git operations via libgit2
│       ├── git_auth.rs         # PAT token storage via OS keychain (keyring)
│       ├── git_provider.rs     # Git provider trait and commands for PRs/issues/CI
│       ├── git_github.rs       # GitHub REST API provider implementation
│       ├── git_gitlab.rs       # GitLab REST API provider implementation
│       ├── git_gitea.rs        # Gitea REST API provider implementation
│       ├── container.rs        # Docker/Podman container and devcontainer management
│       ├── plugins.rs          # Plugin discovery and manifest loading
│       ├── search.rs           # Workspace-wide file search
│       ├── watcher.rs          # File change detection (notify crate)
│       ├── settings.rs         # User settings persistence
│       └── pluto.rs            # Pluto.jl notebook server
│
├── package.json                # Frontend dependencies (React, Monaco, xterm)
├── vite.config.ts              # Vite build configuration
├── tsconfig.json               # TypeScript configuration
└── src-tauri/Cargo.toml        # Rust dependencies (tauri, git2, tokio, etc.)

Tech Stack

Keyboard Shortcuts

Configuration

Settings are stored in ~/.config/julide/settings.json (Linux), ~/Library/Application Support/julide/settings.json (macOS), or %APPDATA%/julide/settings.json (Windows).

Available settings:

Julia Path Detection

julIDE automatically finds Julia using these strategies (in order):

1. juliaPath setting (if set via Settings or the command palette "Set Julia Executable Path")
2. $JULIA_PATH environment variable
3. Login shell which julia lookup
4. ~/.juliaup/bin/julia (juliaup default)
5. Common paths: /opt/homebrew/bin/julia, /usr/local/bin/julia, /usr/bin/julia
6. macOS /Applications/Julia*.app bundles

If Julia is not found, use the command palette (Cmd/Ctrl+Shift+P → "Set Julia Executable Path") to pick a custom binary, or set the JULIA_PATH environment variable.

License

MIT -- Copyright 2026 Ofek Bickel