Preface¶

When developing Rust services in DeepSeek Harness (DSH), a common state is switching between course materials and documentation scattered across browser bookmarks, play.rust-lang.org, and docs.rs. Opening new pages for exercises, and relying on “remembering how far I’ve read” for progress tracking. DeepSeek Harness’s philosophy is “everything is a plugin,” and the sidebar (sidebar.panellist) is inherently reserved for this type of content. The ramanasai/dsh-rust-academy introduced below fills this space with a Rust course featuring exercises, progress tracking, and a syntax cheatsheet. The maintainer is ramanasai, and it is categorized as a client-side plugin.

What is this¶

dsh-rust-academy (package name @local/rust-academy) is a client-side DSH plugin that embeds a Rust course entirely into the Harness sidebar. The README claims to cover 32 tracks and 640 chapters, ranging from fn main to distributed systems; each chapter covers a single narrow concept, arranged from basics to production depth. The repository description itself states “20-lesson Rust course with exercises, progress tracking and a syntax cheatsheet,” while package.json’s description says “six tracks.” These three numbers do not match, which will be explained separately later.

The license is MIT. As of 2026-11-07, the repository has 0 stars, 0 forks, and the latest release is v3.15.0 (2026-11-05). The version in package.json is also 3.15.0. The default branch is main, and the language is JavaScript.

Core Features¶

Course Content. The 32 tracks listed in README cover Rust basics, production-grade web services (axum 0.8), data and persistence (SQLx), microservices and messaging (tonic/gRPC, Kafka, NATS), process handling, production and platform, Rust in depth, algorithms and data structures, database internals, distributed systems, network protocols, security engineering, testing, observability, delivery platform, data engineering, system programming, AI/ML, architecture design, interview preparation, capstone projects, WASM frontends, embedded systems, design principles, engineering craftsmanship, performance engineering, concurrency patterns, API design, debugging, operating systems, and compiler internals. Each chapter, according to the README description, includes objectives, explanations, real code, exercises with hints and solutions, and self-test questions.

Playground. This is the focus of v3.15.0, turning the runtime environment into an IDE style: syntax highlighting, line numbers, auto-indentation, Tab/Shift+Tab, Ctrl/Cmd+/ toggle comments, adjustable font size and line wrapping; output is divided into three panels: Output / Problems / Tests, and the status bar displays Local/Remote, duration, and cursor position. Each code block has a Run button, and exercises offer Open starter / Run solution. Execution goes through the official play.rust-lang.org sandbox (remote, requires internet), but local execution is also possible in a sandboxed temporary workspace when the local runner is enabled. It supports Ctrl/Cmd+Enter to run, Ctrl/Cmd+S to format, Clippy linting, rustfmt, running specific tests with pass/fail summaries, and parsing diagnostic messages.

Others. 12 reference blueprints (master-detail view, request flow, component cards, production checklist, related chapters and references); 40 sets of syntax cheatsheets and 231 snippets that can be copied directly, searchable with one-click “Try in Playground”; tracking by track and total progress; full-text search on chapters / crates / patterns; jumping to specific tracks. Chapter links are categorized and labeled as Docs, Repo, Paper, or Video.

Installation and Activation¶

The installation process given in the README consists of two steps, both from the original text.

Step 1: Clone the repository locally (original command from README):

git clone https://github.com/ramanasai/dsh-rust-academy.git

Step 2: Install the bundle using the Plugin Manager within a Harness session. This step requires Full permissions or approval:

plugin_manager install_bundle target=/absolute/path/to/dsh-rust-academy

The bundle is linked from the check directory, so modifying client.js directly changes the source used by the profile; to use regenerated modules, a reinstall or page refresh is required.

The two slots for plugin registration come from the README:

The host-side index.js is a no-op; the panel does not depend on any Host capabilities. Course data is embedded into the Client module as JSON during the build phase and makes no requests, nor does it access databases or the file system during runtime. Styles only use --dsw-alias-* theme tokens, following Harness for light and dark themes. dsh.bundle.patch in package.json points to ./cordis.patch.yml, and dsh.client.platform is web.

Typical Usage¶

After installation, the rust-academy panel will appear in the left sidebar of the Web GUI. Learning path: Enter a chapter from a track → Read explanations and code → Click “Open starter in Playground” at the exercise → Click “Run solution” to compare after making changes → Check with self-test questions → Completed chapters count toward that track’s progress.

For looking up syntax directly, use the cheatsheet panel: search for keywords, copy the snippet after finding it, or click “Try in Playground” to load the Playground and make changes.

Content Editing and Building¶

This is what maintainers care about. Course content is placed in src/data/*.mjs, one module per track; cheatsheets and blueprints are in reference.mjs; track order is in src/data/index.mjs; src/app.js is the UI template; build.mjs injects data and generates client.js. Validation and build commands:

node scripts/validate-data.mjs src/data/web.mjs   # Validate single track
node build.mjs                                    # Regenerate client.js + compiler gate
node build.mjs --no-snippets                      # Quick local build skipping gate
node --check client.js                            # Syntax check on the artifact

build.mjs runs a compiler gate on every Rust snippet in the course: it requires rustfmt (i.e., rustc parser) to accept it and execute the se... check (truncated in README). There is also an audit script node scripts/audit-content.mjs (npm run audit) and a baseline update command node scripts/compiler-gate.mjs --update-baseline.

Applicability and Notes¶

Suitable for those who want to learn Rust directly within the DSH workflow or provide Rust internal training for a team, especially scenarios where Harness is the primary tool and frequent window switching is undesired. As a client-side plugin, the interface renders in the Web GUI and works on Desktop or dsh web; no npm install is required before installation, as client.js is already committed and has no runtime dependencies.

A few reminders. First, the plugin runs with the permissions of the current DSH process; before installing, open the source code and license to verify, especially noting that dsh.bundle.patch applies cordis.patch.yml. Second, there is a significant inconsistency in the track count in the README: it starts with 32 tracks / 640 chapters, the repository description says 20 lessons, package.json says six tracks, and the sum of chapters in the Track table doesn’t even reach 640; the actual content scale needs to be verified by pulling it down yourself. Third, execution defaults to the play.rust-lang.org remote sandbox; without internet, the local runner needs to be enabled manually and the sandbox configuration confirmed. Fourth, as a client-side plugin listed in the community directory, it has no official affiliation with DeepSeek / Huanfang, and maintenance status and content updates should be observed independently.

Conclusion¶

The value of this plugin lies in squeezing the course, exercises, and runtime environment into the DSH sidebar, using client-side capabilities to achieve no runtime dependencies and no external data sources. The directory page is at https://www.skillhub.cn/plugins/ramanasai/dsh-rust-academy, and the repository is at https://github.com/ramanasai/dsh-rust-academy.