Ruststudio user guide

Ruststudio is an IDE for Rust, written in Rust. It edits, builds, runs, tests and debugs Rust projects, and it manages the packages around them: Rust crates (rupm), native libraries (NuGet) and front-end packages (npm). This guide covers every part of it. Keyboard shortcuts are in their own page, generated from the program.

1. Getting started

1. Install. Run the Windows setup (RustStudioSetup-<version>-x64.exe), or unpack the Linux package. It installs for your user and needs no administrator rights. Ruststudio needs Rust: if rustup is not there, the setup offers to add it.
2. Free week and account. You can use everything for seven days. After that, sign up (free: an e-mail address and a few details, confirmed with a six-digit code) and Ruststudio carries on. You do it inside Ruststudio: the free-week dialog, the account button in the title bar and Help > Sign Up / Account open the sign-up and sign-in form, with no browser and no password. Typing the code from your e-mail links this copy to your account at once.
3. Create a project. File > New Project (Ctrl+Shift+N). Pick a category, a template and a name. Or open a folder that already has a Cargo.toml (File > Open Folder, Ctrl+Shift+O opens a project or solution).
4. Run it. Press F5 to debug, or Ctrl+F5 to run without the debugger. The Output panel shows the build and the program.

The window has a left bar with the views (Explorer, Search, Project structure, NuGet, Rupm, Web, Source control), the editor in the middle, a bottom panel (Terminal, Output, Problems, Debug) and the optional AI assistant on the right. Ctrl+B hides the side bar and Ctrl+J the bottom panel. The Command Palette (Ctrl+Shift+P) runs any command by name.

2. Projects and solutions

• Templates are grouped as Web, Desktop, Mobile, Library and CLI, and Samples and showcase (section 12). Web includes full-stack projects: a Rust (axum) back end serving a React, Vue, Svelte or Angular front end, with settings per environment, a Swagger UI for the API and tests.
• A solution (.rssln) lists several projects, the startup project and the Debug or Release configuration, like Visual Studio's .sln. Ruststudio keeps a generated workspace Cargo.toml in step so Cargo and rust-analyzer see all the projects. File > Add New Project and Add Existing Project add to the open solution. Run > Switch Debug/Release Configuration changes the configuration used by Run and Build.
• The Explorer shows the folder; right-click for actions (new file, new module, reveal in the file manager). Project structure (Ctrl+Shift+U) shows crates, their targets and the module tree, with buttons to run a target.
• Tasks: a solution can list named commands (install, dev server, bundle) that Tools > Run Task starts. Full-stack templates add them for you.

3. The editor

• Highlighting for Rust, TOML, JSON, Markdown, HTML and CSS.
• Language help from rust-analyzer: error and warning squiggles, completion (Ctrl+Space), hover for types and documentation, Go to Definition (F12; if there are several you get a list), and Format Document (Shift+Alt+F). The status bar shows whether rust-analyzer is ready.
• Find in File (Ctrl+F) shows how many matches there are; Enter and F3 go to the next, Shift+Enter the previous. Replace (Ctrl+H) adds a second box: *Replace* replaces the current match and moves on, *All* replaces every match as one step you can undo. Find in Files (Ctrl+Shift+F) searches the whole project; click a result to open it.
• Go to — File (Ctrl+P: type part of a name), Line (Ctrl+G) and Symbol in File (Ctrl+R): a list of the functions, structs, enums, traits, impls, modules and constants of the file (headings in Markdown, tables in TOML) that you can filter by typing.
• Editing: toggle comment (Ctrl+/), duplicate line, delete line, move line up or down, undo and redo, zoom (Ctrl+= and Ctrl+-).
• Saving: a file that ends without a new line gets one, and trailing spaces and tabs are removed from the end of lines (not in Markdown, where two spaces mean a line break). Turn the trimming off with Edit > Toggle Trim Trailing Spaces on Save.
• Tabs: Ctrl+Tab and Ctrl+Shift+Tab switch, Ctrl+W closes. Unsaved changes are asked about before closing.

4. Build, run, test

The Run menu (and the toolbar) has Run, Run (release), Build, Build (release), Check (F7), Test (Ctrl+Shift+T), Clippy, Doc, Format Project and Clean. Output goes to the Output panel; errors and warnings appear in the Problems panel, and clicking one opens the line. Stop (Shift+F5) ends a running task.

Web projects. When a program prints its web address, Ruststudio opens the browser for you. For a full-stack project it opens the front end when the front end says it is ready, and the API documentation (Swagger UI) when the back end says where it is. Runs and debug sessions started from the IDE switch the Swagger UI on even in a Release configuration (deployed programs are not affected).

5. Debugging

Ruststudio debugs with lldb-dap (part of LLVM). Install LLVM; Debug > Debugger Setup lets you point to lldb-dap if it is elsewhere. The Windows installer ships the small Python runtime that lldb needs.

• Breakpoints: click the margin or press F9. They are kept between sessions. F9 on a line with one removes it; Debug > Delete All Breakpoints.
• Run control: F5 starts and continues, F10 step over, F11 step into, Shift+F11 step out, Ctrl+F10 run to cursor, Ctrl+Alt+Break pauses a running program, Shift+F5 stops, Ctrl+Shift+F5 restarts. If the debugger is not set up and there are no breakpoints, F5 just runs.
• The Debug panel has two pages. *Locals and watch*: the call stack, the variables of the selected frame (click to expand), watch expressions and the breakpoint list. *Threads and Immediate*: all threads (a star marks the one that stopped; click one to see its stack, while stepping stays on the thread that stopped) and the Immediate window.
• Immediate window: works while paused. Type a variable (x, person.name, items[0]) to see its value in the selected frame, or any lldb command (bt, thread list, frame variable, register read). Arbitrary expressions such as a + b are not compiled: that crashes some LLVM builds, so Ruststudio does not send them.
• Values are shown the Rust way: a String reads as its text, a Vec as size=3. Hover over a variable in the editor to see its value.
• The debugged program's output goes to the Output panel. Its console window is hidden; a program that reads the keyboard gets an empty input. (Set RS_DEBUG_SHOW_CONSOLE=1 to keep the console, or RS_DEBUG_PLAIN=1 to turn off the Rust value formatting.)
• The debugger stops at rust_panic when your program panics, with the stack that led there.

6. Source control (Git)

View > Source Control, or the circle icon in the left bar. It runs your own git, so it behaves like Git in a terminal and uses the credentials you already have.

• A folder that is not a repository offers Initialize repository (and writes a .gitignore).
• Branch: the button shows the current branch and how far ahead or behind it is; click it to switch to another local branch.
• Changes lists what you changed; M modified, A/U new, D deleted, ! conflict. Click a file to open it. + stages a file, - unstages it, and the circular arrow throws your changes away (after asking). Stage all stages everything.
• Write a message and press Commit (or Enter). Only staged changes are committed. The view refreshes every few seconds, so it also shows what you did in a terminal.
• Push and pull are done in the Terminal for now.

7. Packages

Three kinds, each with a view in the left bar, a Help page with examples (Help menu) and a command line.

Rupm (Rust packages)

The Ruststudio community registry: Rust crates, built from source by Cargo. Search by text, platform (Windows, macOS, Linux, iOS, Android, web) and kind (library, base, tool, template, plugin), and sort by downloads, recent updates or name. Add runs cargo add --registry rupm for the project of the open file. Check updates compares every dependency (rupm and crates.io) with its newest release; Upgrade moves to it. First-party packages include ten basic tools (json-tools, http-tools, csv-tools, config-tools, log-tools, time-tools, id-tools, hash-tools, text-tools, retry-tools) and one package per database driver (db-postgresql-sqlx, db-sqlite-rusqlite, db-redis-redis, ...). Tools > Database Connectors opens the view searching for them.

Command line: rupm search, info, add, outdated, update, upgrade, init, login, publish, yank. To publish your own package, sign in on the website, copy your token from My account (you can revoke it there), run rupm login, then rupm init --platform windows,macos --kind library and rupm publish. The website lists every package with its versions and download counts (Packages page).

NuGet (native libraries)

Many native components (the WebView2 loader, SDKs, C and C++ libraries) ship only as NuGet packages. Search nuget.org, Install, then Use writes a build.rs that links the package's native library and copies it next to your program. Packages are restored into .nuget/packages; Restore all brings back what the solution lists. Tools > Pack Project as NuGet Package makes a .nupkg of a Rust library for .NET.

Web (npm) packages

For the front end of a full-stack project. Ruststudio finds package.json (in web/ or the project) and uses the tool the project uses (npm, pnpm, yarn or bun, from its lock file). You can search npm, add (as a dependency or a dev dependency), upgrade, remove and install everything; the commands it runs are shown in the Output panel. From a terminal, rupm web list|search|add|remove|outdated|upgrade|install|manager does the same (add --dry-run to only see the command). Names and versions that a shell could misread are refused.

8. Terminal

Ctrl+` focuses the Terminal tab, a real shell inside the IDE. Ctrl+C stops a running program. Clear Terminal is in the Terminal menu.

9. AI assistant

Ctrl+Shift+I shows the assistant panel. It talks to the service you choose with your own key: Anthropic, OpenAI and the many services that speak its format (DeepSeek, Groq, Mistral, xAI, OpenRouter, Together, Qwen and local ones such as Ollama or LM Studio), or Google Gemini. Replies stream in. Code in a reply has an Apply button that puts it into the editor (you can undo it, and nothing is written to disk until you save). The assistant works with the files of your project that you include as context, not your whole disk. AI > Settings sets the provider and key.

10. Tools

• Toolchain: Tools > Choose Toolchain picks the Rust toolchain used for Cargo, rustc and rust-analyzer: the one on PATH, any rustup toolchain, or a folder you add.
• Cargo Cleaner (Ctrl+Shift+L) finds target folders and Cargo's caches, shows their size and deletes only what Cargo can regenerate. Automatic cleaning (Tools menu) does it gently in the background: old projects' build output after 30 days, and the open project's target when it passes a size you set.
• Extensions: Tools > Manage Extensions turns optional add-ons on and off; an extension can add project templates and never runs code.
• Mobile: the mobile templates draw their own pixels and run on Android from the same code as the desktop; the New Project page checks the Android SDK, NDK, adb, JDK, Rust targets and cargo-apk and shows the command that fixes what is missing.
• Updates: about once a day Ruststudio asks ruststudio.org whether a newer version exists and tells you; it opens the download page only when you say yes. Help > Update Settings turns the check off.

11. The website and community

ruststudio.org has the downloads, this documentation, the package list (Packages), a Community forum and a place to send feedback. Anyone can read the forum; a free account lets you post. Posts are plain text and show your first name and the initial of your last name. You can delete your own posts. Administrators can lock or delete threads.

12. Samples and showcase

New Project > Samples and showcase has small finished applications, each a real project you can run, read and change:

Each sample has a README with ideas to try, and tests (cargo test).

13. Why Rust

The page "Why choose Rust" compares Rust with Go, C#, Java, Node and Python on speed, memory, size and the bugs each language lets through, with numbers measured on one PC and scripts you can run yourself (benchmarks/). It also says plainly where Rust is not the best choice.

14. Troubleshooting

• Debugging does not start: install LLVM (it provides lldb-dap), then Debug > Debugger Setup. The message says which file is missing.
• No completion or errors: rust-analyzer is not ready or not installed; the status bar says so. rustup component add rust-analyzer installs it.
• A package will not add: open the project's file first (the view uses the project of the open file) and read the message in the view and in Output.
• Git view says Git was not found: install Git for Windows and restart Ruststudio.
• Ask in the Community forum, or send feedback from the website.