Ruststudio user guide
The Ruststudio user guide explains every part of the IDE: projects and solutions, the editor, building and testing, the debugger, Git, packages, the terminal, the AI assistant and the tools.
Updated · describes Ruststudio 0.1.6
Every part of the IDE, in plain language. Keyboard shortcuts are on their own page.
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
- 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: ifrustupis not there, the setup offers to add it. - 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.
- 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). - 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, Tests), 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. Ruststudio keeps a generated workspaceCargo.tomlin 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.
Test (Ctrl+Shift+T) runs every test of the project and shows each one's result in the Test Explorer; running or debugging one test, a module or a file is described in "Testing (0.1.6)" below.
While a task or your program runs, the right of the toolbar shows how it is doing, for example Run ... 12s CPU 3% Memory 24.1 MB 12 threads: the processor share of the whole machine, the memory in use and the thread count of the task and everything it started, refreshed once a second.
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. Debug always debugs: if the debugger is missing it says so and starts nothing (Ctrl+F5 runs without it).
- 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 asa + bare not compiled: that crashes some LLVM builds, so Ruststudio does not send them. - Values are shown the Rust way: a
Stringreads as its text, aVecassize=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=1to keep the console, orRS_DEBUG_PLAIN=1to turn off the Rust value formatting.) - The debugger stops at
rust_panicwhen your program panics, with the stack that led there.
Debugging JavaScript, TypeScript and WebAssembly (front end and Node.js)
F5 on a JavaScript or TypeScript file debugs it; no extra setup beyond Node.js (for scripts) or Chrome / Edge (for web pages). The same Debug panel, breakpoints, stepping, watches, hover and Immediate window are used as for Rust.
- Node.js scripts: open a
.js,.mjs,.cjsor.tsfile and press F5. TypeScript runs throughtsxorts-nodewhen the project has one (npm i -D tsx), otherwise through Node's own type stripping (Node 22.6 or newer). Debug > *Debug Script with Node.js* forces this way. - Web pages and front-end projects: F5 on an
.html,.jsx,.tsx,.vueor.sveltefile, or in a project that uses Vite, React, Vue, Svelte, Angular, Next, webpack and the like, opens your app in Chrome or Edge with the debugger attached (a separate browser profile, so your own tabs and logins are untouched). A plain.htmlfile opens directly. For an app you give its address (it is remembered;http://localhost:5173for Vite is suggested). If nothing answers there and package.json has adev(orstart) script, Ruststudio runsnpm run devfor you and stops it with the session. Debug > *Debug Web App in Browser* forces this way. - Breakpoints go in your own files: set them in the
.ts,.tsxor.vuesource. Source maps (inline or separate files, as Vite, webpack, esbuild and tsc write them) take the debugger to the right line; the stack and the yellow line show your source, not the generated code. Code that runs while the page loads is covered. - Pauses: on breakpoints, on
debugger;statements and on uncaught exceptions (with the error's message). Code insidenode_modulesand Node's own modules is skipped when stepping. - Values read like the browser console:
{a: 1, s: "x"},Array(3) [1, 2, 3],Map(1) {k => v}. *Locals* holds the function's variables andthis; closures, the script and the global scope are listed under it. - Immediate window and watches take JavaScript. Hover and watch expressions never change your program; the Immediate window may.
- WebAssembly: a WebAssembly module is a script like any other. Stop in the JavaScript that calls it and step into the call: the stack shows the WebAssembly function (by its name) above the JavaScript caller. When the module has a source map, frames show the original source file. Line-by-line debugging of Rust compiled to WebAssembly needs DWARF debug info support, which is not in this version.
- The page's
console.logoutput and the dev server's output appear in the Output panel.
6. Source control (Git)
View > Source Control (Ctrl+Shift+G), or the circle icon in the left bar. Every command is also in the Git menu and in the Command Palette (type "Git"). Ruststudio runs your own git, so it behaves like Git in a terminal, runs your hooks and uses the sign-in you already have. It has no Git library of its own and never asks for, sees or stores a password or token.
A folder that is not a repository offers Initialize repository (and writes a .gitignore).
Changes, staging and discarding
The view lists what changed in four groups: Merge conflicts, Staged changes (what the next commit contains), Changes (not staged yet) and Untracked files (new files Git does not know). A file changed again after staging is in both of the middle lists. The letter is Git's: M modified, A added, D deleted, R renamed (with the old name beside it), U untracked, ! conflict.
- + stages a file, - unstages it; the + / - on a group's heading does it for the whole group.
- The circular arrow throws away the unstaged changes of a file and x deletes an untracked file. Both ask first, because this cannot be undone. What is staged is kept.
- Click a file to see its diff; the small file icon opens the file itself. A deleted file has a diff but nothing to open.
- The view is read again when something happened: a command here, a file saved, a build or task finished, Enter in the terminal, or your first key or click after a few seconds away (for example in another window). It does not ask Git on a timer. The round arrow at the top reads it now.
The diff view
A click on a changed file shows a unified diff over the editor: the old and the new line number of every line, removed lines in red with a minus, added lines in green with a plus. The header says which diff it is: *Changes (not staged)*, *Staged changes*, *New file (untracked)* or a commit (from File History).
- F7 and Shift+F7 go to the next and previous change (so do Alt+F3 / Shift+Alt+F3 and the Next / Previous buttons). Enter opens the file at that change, Esc (or Ctrl+W, or Close) goes back to the editor.
- Each change (hunk) has Stage Hunk and Discard Hunk; in the staged diff it has Unstage Hunk. Stage File / Unstage File is in the header.
- To take only some lines, click the added or removed lines you want (click again to unselect): the buttons become Stage 2 Lines, Unstage 2 Lines or Discard 2 Lines.
- Discarding changes the file on disk and asks first. If the file is open with unsaved edits, the editor keeps them and tells you the file changed underneath.
- Binary files and files that are not UTF-8 have no lines to show; they can still be staged or unstaged whole. Line endings of your files are never changed.
- Git > Show Changes of This File opens the diff of the file you are editing, at the change the cursor is on.
Change marks beside the line numbers
In the editor, a bar at the right edge of the line numbers marks lines that are added (green) or changed (blue) since the last commit, and a small red wedge marks where lines were removed. They follow your typing after a short pause, also before you save.
- Click a bar to see what was there before, with Revert Change (puts the committed lines back in the editor; Ctrl+Z undoes it), Stage Change (the file must be saved: Git stages what is on disk) and Show in Diff View.
- Alt+F3 / Shift+Alt+F3 jump to the next / previous change of the file.
- Git > Toggle Change Marks in the Margin switches them off. To compare with what is staged instead of the last commit, set
"git_gutter_base": "index"insettings.json.
Committing
Write the message in the box. The first line is the subject: a counter shows its length against the usual 50 characters, and a second line should stay empty. Ctrl+Enter commits (Enter is a new line); so does the Commit button.
- Only staged changes are committed. When nothing is staged, Commit offers to stage everything and commit (Git > Commit All Changes does that directly; it includes new and deleted files).
- Amend last commit replaces the last commit instead of adding one; the last message is put in the box to edit.
- Files with unsaved changes: you are asked whether to save them first, because Git only sees saved files.
- Your hooks run exactly as Git runs them. What they and Git print goes to the Output panel; if a hook refuses the commit, the panel opens with its message and your text stays in the box.
- If Git does not know your name and e-mail yet, the view says so and shows Set name and e-mail: it asks for both and whether they are for all your repositories or this one, and writes them with
git config. Then commit again.
Branches
The left end of the status bar shows the branch, a * when there are uncommitted changes, and arrows with the number of commits to push (up) and to pull (down), for example main* ↑2 ↓1. Click it (or the Branch button of the view, or Git > Switch Branch) for the list:
- your local branches (Enter switches), remote branches that have no local branch yet (Enter makes a local branch that tracks it), New branch (created from where you are; uncommitted changes come along), and Delete merged branch for branches whose commits are all in the current one.
- Nothing is ever forced. If uncommitted changes are in the way of a switch, or a branch is not merged, Git refuses, its message is shown in the Output panel with what to do, and nothing is changed.
- After a switch, open files without unsaved edits show the branch's text; files with unsaved edits keep them and say so.
Fetch, pull and push
The three buttons under the commit box (also in the Git menu). They show how many commits are waiting, their output and progress go to the Output panel, and Cancel (or Shift+F5) stops one that is running. A command that takes longer than ten minutes is stopped ("git_timeout_secs" in settings.json).
- Pull is fast-forward only: it never merges or rebases on its own. If your branch and its upstream both have new commits, Git refuses and Ruststudio asks whether to merge or rebase (Git > Pull (Merge) and Pull (Rebase) do that directly).
- Push of a branch that is not on a remote yet is shown as Publish and asks before it creates the branch there and sets it as upstream (
git push --set-upstream origin <branch>). A push that the remote rejects tells you to pull first. Nothing is force-pushed. - Signing in: Ruststudio does not ask for credentials. Git uses your credential helper (Git Credential Manager on Windows, the keychain on macOS, libsecret or a cache on Linux) or your SSH agent; a helper that has its own window may show it. Git is run so that it can never wait for a password typed in a terminal. If the remote refuses, the message says to sign in once with your helper, for example by running
git fetchin the Terminal, and to try again.GIT_ASKPASSandSSH_ASKPASSare left as you set them.
Merge conflicts
After a pull or merge with conflicts the files are listed under Merge conflicts. Click one to open it: the two sides are tinted (yours, then the incoming one). Put the cursor inside a conflict and choose Git > Accept Current Change, Accept Incoming Change or Accept Both Changes (also in the right-click menu). When no markers are left, save the file and press the check mark beside it in the view (that stages it, which tells Git it is resolved), then commit.
Blame and file history
- Git > Toggle Blame for the Current Line shows, at the end of the line the cursor is on, who changed it last, when and in which commit. It is off at first; it is shown for a file without unsaved edits.
- Git > File History lists the commits that changed the open file, also across a rename; Enter shows what that commit did to it.
What is not there yet
A side-by-side diff, stash, tags, cherry-pick, an interactive rebase and a commit graph are not in the IDE; use the Terminal for those.
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, connector), and sort by downloads, recent updates or name. Add runs cargo add --registry rupm for the project of the open file. The Source button also searches crates.io, registries you added, or all of them at once (see *Package sources in Ruststudio* below). 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 lists the connectors (see *Database connector packages* below); the last row of that list opens this view searching for the database packages.
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 your NuGet sources (nuget.org, the Ruststudio feed and any you added; each result names its source), 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.
Package sources: rupm and NuGet
Ruststudio runs two public package registries. Anyone can read them; a free Ruststudio account can publish to them. They work with the standard tools, with or without the IDE.
| Registry | For | Address | Browse |
|---|---|---|---|
| rupm | Rust crates (a Cargo registry) | sparse+https://www.ruststudio.org/rupm/index/ | https://www.ruststudio.org/rupm/packages |
| NuGet | .NET packages and native libraries (a NuGet V3 feed) | https://www.ruststudio.org/nuget/v3/index.json | https://www.ruststudio.org/nuget/packages |
Add the sources (once). For Cargo, put this in .cargo/config.toml in the project or in your home folder (Ruststudio and rupm write it for you):
[registries.rupm]
index = "sparse+https://www.ruststudio.org/rupm/index/"For NuGet:
dotnet nuget add source https://www.ruststudio.org/nuget/v3/index.json -n ruststudioEach registry has this one address. The rupm address is the one existing projects already use, so Cargo.lock files do not change.
Install a package. In Ruststudio: the Rupm or NuGet view, search for the name, Install. From a terminal:
cargo add <name> --registry rupm
dotnet add package <Id> --source https://www.ruststudio.org/nuget/v3/index.jsonEach package's page on the website shows these commands filled in, the Cargo.toml line or <PackageReference> element, the README, every version and the dependencies.
Create an API key. Sign in on the website and open Packages. Under *Your API keys* choose a name, what the key may do (*push*, or *push and yank/unlist*), which package names it is for (* for all, or a pattern such as Contoso.* or my-*) and how long it lasts (up to one year). The key is shown once: copy it then. The list shows when each key was last used, and Revoke ends a key at once. Give each machine or build pipeline its own key. (The older account-wide rupm token from My account still works.)
Publish.
cargo publish --registry rupm --token <your key>
dotnet pack -c Release
dotnet nuget push bin/Release/MyPackage.1.0.0.nupkg --source https://www.ruststudio.org/nuget/v3/index.json --api-key <your key>rupm login then rupm publish does the same for a crate. A crate may state what it is for in Cargo.toml ([package.metadata.rupm] with platforms = ["windows", "linux"] and kind = "library"); a NuGet package needs an id, a version, authors and a description, as dotnet pack writes them. The README in the package is shown on its page.
Publish from the website (no command line, no API key). Sign in (or create an account: an e-mail address and the 6-digit code we send to it), open Packages and choose Publish a package, or go straight to /packages/upload. Choose the registry, then drop or choose the file: for rupm the .crate that cargo package writes to target/package/, for NuGet the .nupkg that dotnet pack writes. The page first shows what the server read out of the file: name, version, description, licence, authors, dependencies, the start of the README and the size, and, if the package would be refused, the reason in plain words (the version already exists, the name is reserved or too close to a well-known one, the account is over its quota). Nothing is public until you press Publish; the file waits 15 minutes for that. After publishing you get a link to the package's page. The rules and limits are exactly those of cargo publish and dotnet nuget push.
Who owns a package. The first account to publish a name owns it, and only that account can add versions. A package has one owner; co-owners cannot be added yet.
Yank or unlist. cargo yank <name>@<version> --registry rupm --token <key> (and --undo), dotnet nuget delete <Id> <version> --source ... --api-key <key>, or the buttons under *Your packages* on the website. This needs a key with the *push and yank/unlist* scope. It hides the version from search and from new projects; projects that already use it still restore and build. Nothing is deleted, and a version number can never be used again.
Rules and limits.
- A version is published once and cannot be replaced: publish a higher version instead. Versions are SemVer 2 (
1.2.3,1.2.3-beta.1). - Reserved names: on rupm, names that start with
rs-orruststudio; on NuGet, the id prefixesRuststudio.andFowlguard.. They are for Ruststudio's own packages. - A name that is one typing slip away from a well-known package (for example
tokoi,Newtonsoft.Jsom) is refused. - Size: a crate up to 10 MB, a NuGet package up to 100 MB. Per account: 100 packages, 2 GB in total, 50 uploads in 24 hours. Uploads and searches are also rate limited per address.
- Packages that break the rules can be unlisted or removed, and an account can be stopped from publishing. Use the feedback page to report a package.
Package sources in Ruststudio
The Rupm and NuGet views search the sources that are switched on. Four are built in: nuget.org and ruststudio (NuGet), and crates.io and rupm (Cargo). You can add your own: any NuGet V3 feed (its address ends in /v3/index.json) and any Cargo sparse registry (sparse+https://host/path/).
- Source picker. The button under the search box says which source is searched: *All sources*, or one of them; click it to go to the next. The NuGet view starts on *All sources*, the Rupm view on *rupm*. Every result shows the source it came from, its version, its description and, where the source says so, its downloads. A source that cannot be reached is named with the reason (offline, the address is wrong, the secure connection failed, too many requests); the others still answer. Every request has a time limit and runs in the background.
- Install (NuGet) and Add (Rupm) take the package from the source its row names. For a Cargo registry other than crates.io the project's
.cargo/config.tomlgets a[registries.<name>]entry if it has none; an entry that is already there is never changed, and no key is ever written into a project. - Page opens the package's page in your browser: the Ruststudio website for rupm and the Ruststudio feed, nuget.org and crates.io for theirs.
- Restore all (NuGet) takes each package the solution lists from the first source, in the order of the list, that has that version. The solution file records ids and versions, not sources.
- Sources... (in both views; also Tools > Packages: Manage Sources, and the Command Palette) opens the list. There you add, edit and remove your own sources, switch any source on or off, enter an API key, and Test connection, which reads the source's own description of itself and says whether it answers and whether it accepts uploads. The built-in sources keep their names and addresses.
API keys. Only publishing needs a key. Create one on the website (Tools > Packages: My Packages and API Keys, or Get a key in the sources list), then paste it into the source's *API key* box. The box shows dots, and the key is not copied back out of it. The key is saved in your user settings file (settings.json in the Ruststudio settings folder, package_sources), not in any project. To keep it out of that file too, enter env:NAME and put the key in the environment variable NAME. A key is sent only in a request header to the source it belongs to, only over https (plain http is accepted only for this computer), never in an address; a redirect to another server is not followed when a key is sent. It is removed from everything shown in the Output panel.
Another server. Ruststudio's two registries live under one site address: <site>/rupm/... and <site>/nuget/.... To use another site, for example a server on your own machine, set the environment variable RUPM_SERVER=http://127.0.0.1:8080 (the rupm command line reads it too) or the setting "packages_server" in settings.json. In settings.json the sources look like this:
"package_sources": {
"nuget": [
{ "name": "nuget.org", "enabled": true },
{ "name": "ruststudio", "enabled": true, "api_key": "env:RUSTSTUDIO_KEY" },
{ "name": "Company", "url": "https://nuget.example.com/v3/index.json", "enabled": true }
],
"cargo": [
{ "name": "crates.io", "enabled": true },
{ "name": "rupm", "enabled": true, "api_key": "env:RUSTSTUDIO_KEY" }
]
}Publishing from Ruststudio
- Publish to rupm (Tools > Packages: Publish to rupm, the Command Palette, or Publish... in the Rupm view) publishes the package of the open file. A dialog first shows the package name, the version, the registry and its address, and whether a key is set; it says that publishing is public and that a version can never be changed or reused. Dry run packs and verifies and uploads nothing; it needs no key. Then
cargo publish --registry <name>runs in the Output panel (Shift+F5 stops it). The key goes to cargo through an environment variable, so it is not on the command line, not in the panel and not in any file; the registry's address is given the same way, so the key goes to the registry the dialog named whatever the project's own.cargo/config.tomlsays. When it is done the address of the package's page is shown and put on the clipboard. If the registry refuses (the key, a reserved name, a version that exists), cargo's message is shown with a line of advice. - Publish to NuGet (Tools > Packages: Publish to NuGet, Publish... in the NuGet view, or Publish beside a package under *Local packages*) pushes a
.nupkgthat Tools > Pack Project as NuGet Package made. The same dialog asks first; with more than one NuGet source you choose the registry there. Dry run checks that the file is a readable package, that the source accepts uploads and that it does not have that version yet. The upload does not need dotnet. A refusal shows the server's own words: the version already exists (409), the id is reserved (403), the id is too close to a well-known package (400), a quota, or the key (401). - My Packages and API Keys opens the website's Packages page, where your packages, their downloads, yank/unlist and your keys are.
Publishing to crates.io is not done from these commands: use cargo publish in the Terminal.
Install links (ruststudio://install)
A package's page on the website has an Install in Ruststudio button. It opens a link such as ruststudio://install?registry=rupm&name=json-tools&version=1.2.0 (registry is rupm or nuget; version may be left out for the newest release). The installers register that kind of link for your user account, and remove it when Ruststudio is uninstalled.
Any web page can show such a link, so Ruststudio treats it as untrusted: the registry must be one of the two words, the name and the version must be a valid name and version (nothing is decoded, and anything else is refused with a message), and the link cannot name a server: the package is looked up on your own *rupm* or *ruststudio* source. Ruststudio then asks: *Install json-tools 1.2.0 from rupm into my-project?*, with the description, the downloads and the source's address. Only Yes installs, with the same steps as Add or Install in the package views. With no project open it asks to open one first. If Ruststudio is already running, the link goes to the open window (on Windows and Linux within a few seconds; the window may not come to the front by itself).
Database connector packages (rupm and NuGet)
Six database connectors are Ruststudio's own packages, on both registries. Each is a thin layer over a well-known Rust driver with one small API, rs-db, so a program talks to every database the same way. The Rust crate is on rupm (kind connector); the same connector, with its native library and a generated C# class, is a .NET package on the NuGet feed.
| Database | Rust (rupm) | .NET (NuGet) | Driver inside | A statement is |
|---|---|---|---|---|
| SQLite | rs-db-sqlite | Ruststudio.Db.Sqlite | rusqlite, SQLite bundled | SQL |
| PostgreSQL | rs-db-postgres | Ruststudio.Db.Postgres | postgres | SQL |
| MySQL / MariaDB | rs-db-mysql | Ruststudio.Db.MySql | mysql | SQL |
| SQL Server | rs-db-sqlserver | Ruststudio.Db.SqlServer | tiberius | SQL |
| MongoDB | rs-db-mongodb | Ruststudio.Db.MongoDb | mongodb | a database command as JSON: {"find": "items"} |
| Redis / Valkey | rs-db-redis | Ruststudio.Db.Redis | redis | a command line as in redis-cli: GET key |
Install (any Cargo project that knows the rupm registry, any .NET 6+ project):
cargo add rs-db-sqlite --registry rupm
dotnet add package Ruststudio.Db.Sqlite --source https://www.ruststudio.org/nuget/v3/index.jsonThe rs-db API, in Rust (every connector crate re-exports it, so one cargo add is enough):
use rs_db_sqlite::{transaction, Connector, SqliteConnector};
fn main() -> rs_db_sqlite::Result<()> {
let mut db = SqliteConnector::connect("app.db")?; // the engine's own connection string
db.execute("CREATE TABLE IF NOT EXISTS item (id INTEGER PRIMARY KEY, name TEXT NOT NULL)")?;
let changed = db.execute("INSERT INTO item (name) VALUES ('first')")?; // rows changed
let rows = db.query("SELECT id, name FROM item")?; // column names and typed values
println!("{changed} added, {} row(s): {}", rows.len(), rows.to_json()); // [{"id":1,"name":"first"}]
transaction(&mut db, |db| db.execute("DELETE FROM item"))?; // commit on Ok, roll back on Err
db.close()
}and the same connector in C#:
using Ruststudio.Db.Sqlite;
using var db = SqliteConnector.Open("app.db");
db.Execute("INSERT INTO item (name) VALUES ('first')");
foreach (var row in db.Query("SELECT id, name FROM item")) Console.WriteLine(quot;{row["id"]} {row["name"]}");
Console.WriteLine(db.QueryJson("SELECT COUNT(*) AS n FROM item")); // [{"n":1}]A value is null, a boolean, a 64-bit integer, a floating-point number, text or bytes. Types that would lose precision (decimals, dates, UUIDs) arrive as text exactly as the database writes them. Errors carry the database's own message. The API is blocking: no async runtime is needed to call it. inner() gives the driver's own connection for what rs-db leaves out.
In Ruststudio: Tools > Database Connectors lists every connector of the catalogue (28 for 17 databases). A row that is also a Ruststudio package says so. When you choose one, Ruststudio asks your *rupm* source whether it has the package; if it does, you are offered Ruststudio connector (rupm) first and The driver itself second. The package is added with cargo add <name> --registry rupm, your project's .cargo/config.toml gets the registry if it does not name it yet (never a key), and examples/db_<database>_rs_db.rs, written with the rs-db API, is created and opened: edit the connection string and press Ctrl+F5. If the rupm source is switched off, cannot be reached or does not have the package, the driver is added exactly as before and the Output panel says why. The last row of the list opens the Rupm view on all database packages.
Limits of version 0.1: statements are sent as text; there are no bound parameters, so never build a statement from input you do not trust (use inner() and the driver's parameters for that). PostgreSQL, MySQL and Redis connect without TLS only. MongoDB transactions are not covered. The .NET packages carry the native library for Windows x64 only. The other 22 connectors of the catalogue still add the driver itself.
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
targetfolders 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'stargetwhen 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 or iOS from the same code as the desktop. Tools > Android: Setup Check looks for the Android SDK, NDK, adb, JDK, Rust targets and
cargo-apk; Tools > iOS: Setup Check does the same for Xcode and the iOS tools. Both show the command that installs what is missing. iOS apps need a Mac: see "iOS apps" below. - 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. A newer version also shows in the status bar until you install it.
- Usage sharing (off until you agree): Ruststudio asks once, in a small card in the corner that never blocks your work, whether to share anonymous usage numbers. If you say yes, about once a week it sends how long and how often it was used, how many times each of a fixed list of features was used (Run, Build, Debug and so on) and which kinds of project were opened (web, library, Android and so on), with the version, system and the random install id. It never sends code, file or project names, paths, commands or errors. Help > Usage Sharing turns it on or off; turning it off deletes the numbers kept on your computer.
- Rating: now and then (at most every 45 days, never in the first week) a card asks for one to five stars. Pressing one sends only the number, the version and the system. It can be dismissed, and "Don't ask again" ends it for good.
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:
| Sample | What it shows |
|---|---|
| Data grid | 100,000 rows sorted, filtered and paged by a Rust server on every request, with the time Rust took |
| Charts dashboard | bar, line and donut charts with tooltips, drawn as SVG from numbers worked out in Rust |
| Kanban board | drag-and-drop cards kept by a Rust server with a JSON API |
| Scheduler | a month calendar with events, dates and times validated in Rust |
| Markdown editor | a split editor whose preview is rendered by Rust and never runs raw HTML |
| To-do list API | a first web service with shared state and API tests |
| Word count | a first command-line program with tests |
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-analyzerinstalls 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.
- The Test Explorer says the tests could not be listed: the project does not build at the moment. Fix what the Problems panel shows (Run > Check, F7), save, and the list comes back; the tests it knew before stay in the list meanwhile.
- No Run and Debug icons beside a test: the file must be saved inside a package (in
src,tests,examplesorbenches), and View > Test: Toggle Run and Debug Icons in the Margin must be on. - Push or pull says the sign-in failed: Ruststudio never asks for a password. Run
git fetchonce in the Terminal and complete the sign-in with your credential helper (orssh-addyour key), then use the button again. The Output panel has Git's own message. - A Git command says another Git process is running: wait for it, or, if a crashed Git left it behind, delete
.git/index.lock. - Ask in the Community forum, or send feedback from the website.
Editing and navigating code (0.1.4)
Everything here is also in the menus and the Command Palette (Ctrl+Shift+P); docs/shortcuts.md lists the keys.
- Peek Definition (Alt+F12) shows the definition in a card under the editor. Find All References (Shift+F12) lists every use. Go to Implementation (Shift+Alt+F12) and Go to Type Definition work the same way. These need rust-analyzer (open a Cargo project).
- Rename Symbol (F2) renames a name everywhere in the project. Quick Fix (Ctrl+.) lists the fixes rust-analyzer offers at the cursor.
- Edit menu: Join Lines, Sort Lines, Remove Duplicate Lines, Trim Trailing Whitespace, Insert Line Above / Below, Copy Line Down, and Transform to UPPERCASE / lowercase / snake_case / camelCase / PascalCase (on the selection, or the word at the cursor). Go to Matching Bracket (Ctrl+Shift+\) jumps between a bracket and its partner.
- Go menu: Close Other Editors, Close All Editors, Copy File Path.
- Run menu: Cargo: Add Dependency (type
serdeortokio@1) and Cargo: Update Dependencies. - Run and Debug are separate. Run (Ctrl+F5) starts the program without the debugger; Debug (F5) always debugs and tells you if the debugger is missing.
- More editing commands: Reverse Lines, Surround with Quotes / Parentheses, Toggle Block Comment, Delete to End of Line, Transpose Characters, Convert Tabs to Spaces. Expand Macro shows a macro's expansion in the Output panel; Open Cargo.toml opens the nearest manifest; Reopen Closed Editor brings back the last file you closed.
- More Cargo commands (Run menu): Apply Compiler Fixes (
cargo fix), Apply Clippy Fixes, Show Dependency Tree, Run Benchmarks.
Seeing more while you code (0.1.6)
Inlay hints
Ruststudio shows what rust-analyzer knows about your code inside the code, in dim text: the type of a let that has none written (let total: u32 = ...), the parameter names at a call (resize(width: 800, height: 600)), and the type after each step of a chain of method calls. The hints are not part of the file: they are never saved, copied or selected, the caret skips them, and a click on one puts the caret where the hint is attached. A long type is cut with an ellipsis.
- Hints are asked for the lines on screen only, a moment after you stop typing, so scrolling and typing stay as fast as before. While you type on a line its hints go away and come back when rust-analyzer has caught up.
- Turn them off or on with View > Toggle Inlay Hints (also in the Command Palette). The choice is kept.
- They need rust-analyzer (open a Cargo project); while it is still loading the project there are few or none.
Variable values in the editor while debugging
When the program is paused, the values of the current function's variables are shown in dim italics at the end of the lines that use them, for example let sum = a + b; sum = 42, a = 20, b = 22. You see them from the start of the function down to the line the program stopped on, for the frame selected in the call stack.
- The values are refreshed at every stop and step, and they go away when the program runs on or the session ends.
- A long value is cut; the full value is in the Debug panel and in the hover.
- If two variables have the same name (shadowing), the newer one is shown on every line that uses the name.
- Turn them off or on with Debug > Toggle Inline Values While Debugging (also in the Command Palette). The choice is kept.
Go to Implementation
Go to Implementation (Shift+Alt+F12, also in the Go menu and the editor's right-click menu) answers "who implements this?". On a trait it finds the impl blocks, on a trait method the methods that implement it, on a struct or enum its impl blocks. One result opens straight away; several are listed the way Find All References lists them, each with its line of code: type to filter, Enter opens. Ctrl+F12, the key of version 0.1.5, still works.
Testing (0.1.6)
Ruststudio finds the tests of your project, runs one, some or all of them and shows what each did, and debugs a test with the same debugger as F5. Everything goes through your own cargo test, with the Rust toolchain you chose (Tools > Rust Toolchain) and the Debug or Release configuration of the solution.
Run and Debug icons beside tests
Beside every test function the margin of the editor has two small icons: a triangle that runs the test and a bug that debugs it. fn main of a program has them too (they are Run and Debug of the program).
- The icons come from the text you are editing, a moment after you stop typing. They need no build and no rust-analyzer, so they are there as soon as a file is open. A function counts as a test under
#[test], any attribute that ends in::test(#[tokio::test],#[async_std::test],#[actix_web::test]...),#[rstest]and#[test_case(..)]. - After a run the triangle shows the result: a green tick when the test passed, a red cross when it failed, a dot while it runs. Click it to run the test again.
- The margin, left to right: breakpoints (click to set one), the Run and Debug icons, the line numbers, the dot of an error or warning, and the Git change bar at the right edge. The icon column is only there in files that have tests, so other files keep their width. Nothing overlaps: a click on an icon never sets a breakpoint, and a click on a change bar still opens its menu.
- Keys: F6 runs the test the cursor is in (in a test module but outside a test: the tests of that module), Shift+F6 debugs it, Ctrl+F6 runs all tests of the file, Ctrl+Shift+F6 runs the last run again. The same commands are in the Run menu, in the editor's right-click menu (Run Test, Debug Test) and in the Command Palette as *Test: Run Test at Cursor*, *Test: Debug Test at Cursor*, *Test: Run All Tests in File* and *Test: Rerun Last*.
- Turn the icons off or on with View > Test: Toggle Run and Debug Icons in the Margin. The choice is kept.
The Test Explorer
Open it with Alt+F6, View > Show Test Explorer or the checklist icon in the left bar. It lists the tests as a tree: the package, its test binaries when it has several (lib, bin name, tests/name, doc tests), the modules, and the tests. Each row shows the result of its last run: not run, running, passed, failed or ignored; a package or module shows failed as soon as one test in it failed, and passed when all of them passed.
- Where the list comes from. Cargo itself (
cargo test -- --list), so it is exactly whatcargo testwould run, including doc tests and tests marked#[ignore](shown dimmer). Cargo has to build the tests to list them: the first time that takes as long as a build, in the background at low priority, and you can keep working. The list is read again a moment after you save a Rust file or aCargo.toml(once you have used the view) and when you press Refresh; never on a timer. While the project does not build, the list stays as it was and the view says why. - Run All (Ctrl+Shift+T) runs everything. Run Failed runs the tests that failed. Run and Debug work on the selected row: a package, a binary, a module or one test. Stop (Shift+F5) ends the run. A row under the mouse has its own run and debug buttons, and a right-click menu (Run, Debug, Go to Source, Copy Name).
- Ignored too makes runs include the tests marked
#[ignore]. A single ignored test that you run by itself always runs. - Filter: type in the box to keep the tests whose name contains the text. With the box focused, the arrow keys move through the rows, Enter opens the selected test (or opens and closes a row), Esc goes back to the editor.
- Double-click a test to open its source at the test function. The buttons at the top right refresh the list, collapse all rows and expand all rows.
- The line above the list counts along while tests run and then says how it ended, for example
11 passed, 5 failed, 2 ignored - 3.4 s.
Running tests
- A run is an ordinary task: its output is in the Output panel as it is printed (the tests' own
println!output included), the toolbar shows that it runs, and there is one run at a time. Each test's result appears in the Test Explorer and in the margin the moment its line arrives, not at the end. - A failed test has a line under it with the place and the message of the panic, for example
src/lib.rs:33 assertion failed: math is hard. Click it to go to the assertion. Failed tests are also listed in the Problems panel, like build errors. - Stop ends the run and everything it started. Tests that had not reported yet keep the result they had before.
- A run that takes longer than 30 minutes is stopped (
"test_run_timeout_secs"in settings.json; 0 means no limit). - In a solution, the environment variables of the solution's project are given to the tests of that project.
- Doc tests are listed and run like the others. Cargo cannot be told the full name of one doc test, so running one uses its line number: a doc test at line 5 also runs the doc tests at lines 15, 25 and so on of the same package.
Debugging a test
Shift+F6 in a test, the bug icon beside it, or Debug in the Test Explorer builds the test program (cargo test --no-run) and starts it under the debugger with just that test. Breakpoints in the test and in the code it calls are hit, and everything from "Debugging" above applies: stepping, the Debug panel, hover, and the variable values at the end of the lines. When the test finishes, its result is shown like that of a run. Doc tests cannot be debugged (rustdoc builds and runs them itself); a test with several cases (#[rstest] with #[case]) is debugged from its row in the Test Explorer, one case at a time.
Settings
In settings.json: "test_gutter" (the margin icons, on by default), "test_auto_discover" (read the list again after a save, on by default), "test_run_timeout_secs" (1800; 0 for no limit) and "test_discovery_timeout_secs" (600: how long finding the tests, which includes building them, may take).
What is not there yet
- No code coverage, and no time per test (Cargo's stable output has none).
- Results are kept while the folder is open, not between sessions.
- A test that a macro generates is listed and runs, but has no icon in the margin, and "Go to Source" opens its file rather than its line.
- In a folder with several packages that have no common
Cargo.toml, Run All runs the package of the file you are in; the Test Explorer lists them all, and you can run each package from its row.
iOS apps (0.1.6, first version)
Status: not yet verified on a real Simulator or iPhone. This first version was written and tested on Windows, against stand-ins for Apple's tools. This sentence will be replaced by the macOS, Xcode and iOS versions it was verified on.
Ruststudio builds, runs and debugs native iOS apps written in Rust: the app's interface is drawn by Slint or egui, not by a web view. It uses Xcode's command-line tools for the building and the launching (xcodegen, xcodebuild, xcrun simctl, xcrun devicectl, Xcode's LLDB) and does the rest itself. You do not open Xcode.
iOS needs a Mac
Apple's iOS SDK, the Simulator and code signing exist only on macOS, so an iOS app can only be built on a Mac with Xcode installed. On Windows and Linux the iOS templates still work as desktop programs: you write, run and debug the app as a window (F5), and open the same project on a Mac to run it on iOS. There the toolbar chip says iOS needs a Mac, and the iOS commands and tasks say the same instead of starting. Android apps build on every system.
The templates
New Project > Mobile has Native iOS app (Slint) and Native iOS app (egui), next to the Android ones. Slint supports iOS officially; egui on iOS is experimental. Each project is one Rust program (src/lib.rs with the app, src/main.rs that starts it) plus an ios/ folder:
project.ymldescribes the Xcode project: name, bundle identifier (com.example.<name>: change it before you ship), the lowest iOS version, the Info.plist keys. Ruststudio makes the.xcodeprojfrom it with XcodeGen before every build, so there is no Xcode project to edit or to keep in Git.build-rust.shis the build step that runscargo buildfor the iPhone or the Simulator and puts the program into the app.Assets.xcassetsholds the app icon: a plain placeholder, to be replaced by your own 1024 x 1024 PNG.run-simulator.shandbuild.shdo the same from a terminal.
The Tauri 2 mobile template is still there for apps with an HTML front end.
Setup check
Tools > iOS: Setup Check lists what an iOS build needs, each with a tick or a cross, and the full text in the Output panel: Xcode (the full app, licence accepted), the command line tools, the iOS and Simulator SDKs, an installed Simulator, XcodeGen, the Rust targets and the signing team. A row with a cross shows the command that installs the piece (brew install xcodegen, rustup target add aarch64-apple-ios aarch64-apple-ios-sim, xcodebuild -downloadPlatform iOS); Enter runs it in the Output panel. A command that needs your password (sudo ...) is copied instead, to paste into the Terminal. On Windows and Linux the check says that a Mac is needed and what works on that computer. Tools > Android: Setup Check is the same for Android.
Choosing where to run
An iOS project has a chip in the toolbar, after Debug/Release. It says Desktop at first. Click it (or Run > iOS: Choose Destination) for the list: Desktop, the installed Simulators (newest iOS first, a running one marked) and the iPhones and iPads that are connected. The list is read again every time it opens, in the background. The choice is kept with the solution.
With Desktop, Run and Debug start the program as a window, as for any Rust project. With a Simulator or an iPhone:
Run (Ctrl+F5)
Ruststudio writes the Xcode project, builds it (the Rust code is built by cargo inside that build), starts the Simulator if it is not running, installs the app and starts it. Every command and its output is in the Output panel. What the app prints (println!) appears there too. Stop (Shift+F5) ends the app on the Simulator or the iPhone and any step that is still running. If the build fails, Rust's errors and Xcode's errors are listed in the Problems panel with their file and line, and nothing is installed. Each step has a time limit, so a tool that hangs is ended and named.
Run > iOS: Build App only builds. The solution's Debug/Release configuration is used for all of it.
Debug (F5)
On a Simulator the app is started paused, and the debugger (Xcode's lldb-dap, or the one set under Debug > Debugger Setup) attaches to it before its first line runs. Breakpoints in your .rs files, stepping, the call stack, variables, watches and the values shown in the editor work as described under "Debugging". The build keeps the debug information (a .dSYM beside the app) for that.
Debugging on an iPhone is unverified. Ruststudio starts the app paused on the phone and asks LLDB to attach through the device connection, in the way Xcode 15 and 16 document, but this has never been run on a real phone. If it cannot attach, the Output panel shows LLDB's own message followed by "iPhone debugging could not attach; see Output", and the app is ended. Run on an iPhone does not depend on it. While debugging on an iPhone the app's println! output is not shown.
An iPhone and signing
An iPhone only runs apps signed by an Apple Developer team. Tools > iOS: Signing Team asks for the team ID (10 letters and digits) and keeps it in the solution file. A free Apple ID is enough for your own phone; a paid membership is needed for the App Store. Two things are done once, outside Ruststudio: add your Apple ID in Xcode > Settings > Accounts (so Xcode can create the signing profile; this is the only time Xcode's window is needed), and turn on Developer Mode on the phone (Settings > Privacy & Security). The Simulator needs neither. When signing fails, the Output panel adds what to do.
Tasks
The templates add Run on iOS Simulator, Build iOS app and iOS devices to Terminal > Run Task. They run the scripts in ios/ and work without the toolbar chip.
What is not there yet
- Verification on real hardware (see the status line at the top of this section).
- Building for iOS from Windows or Linux (for example on a Mac over the network).
- App Store builds: archive, export and upload are not automated.
- The app's output while debugging on an iPhone; a log viewer for the device.
- One project for Android and iOS together: the Android and the iOS templates are separate, with the same app code.