Make it comfortable to read
Choose Light, Dark or Auto from the website header. Auto follows the device appearance as it changes. The setting is saved in this browser and applies to learning pages, the journal, the playground and Memory Lab. Clearing browser site data resets this choice to Auto.
In the iPhone and iPad app, open Settings → Appearance. The same setting applies to the native journal and the bundled Memory Lab. Existing saved choices are preserved; a new installation starts in Auto.
Open Learn → The .NET journal to read all eight articles and their illustrations offline. Three newer articles include complete downloadable .NET 10 projects for desktop experiments with API readiness, memory ownership and bounded asynchronous work. Downloading a project or opening a reference requires a connection.
iPad and iPhone Duo
On iPad, the workspace follows the window width. A wide window shows files and tools beside the code; a compact window keeps the editor wide and opens panels on demand. Use the file, Find and output buttons to reach the tools you need. Lesson text stays within a readable column; swipe long code horizontally rather than shrinking it to unreadable type.
On iPhone Duo, open the device partway in laptop posture. Tap the upper editor to type: the system software keyboard occupies the lower display, while SharpRune keeps the editor above the division. When the keyboard is dismissed or a hardware keyboard is used, the lower workspace can show output and other tools. The division itself is kept clear.
Keyboard availability and placement follow iOS. If a connected hardware keyboard hides the software keyboard, use the system keyboard control to show it when needed. Rotate or fully open the device to change posture. Choose Light, Dark or Auto in Settings; editor text size and accessibility text settings can be adjusted independently.
Run your first C# program
Open the playground, choose an example or keep the initial LINQ program, then select Run locally. The first run downloads the browser compiler and runtime; on a slow connection this can take time. Subsequent runs in the same session reuse the runtime unless you stop it or a timeout requires a new worker.
The initial program keeps 12 and 25 from the prices array and prints 37. Change the comparison from >= 10m to >= 20m and run it again. The result becomes 25. This small experiment is a useful way to connect a predicate to the values that reach Sum.
using System;
using System.Linq;
var prices = new[] { 12m, 8m, 25m };
Console.WriteLine(prices.Where(p => p >= 10m).Sum());Move from a lesson to code
Each lesson includes an explanation, a working sample, a hint and expected output where applicable. Open in playground loads a copy of that sample. Editing the copy never changes the lesson. Mark complete records progress only in the current browser, using local storage.
A project example loads its C# files together. Program.cs holds top-level statements; supporting types can live in their own files. The public playground exposes a compact file list, prepared input, compiler diagnostics and output. Download project saves all current source files and a .NET 9 project file in a ZIP archive. The example page keeps every original source file available for copying.
Run complete .NET 10 SDK projects
Modern C# 14, ASP.NET Core, EF Core, architecture and load lessons include complete external SDK projects. Download the project ZIP from the lesson, extract it and follow its environment and setup instructions. The archive preserves its target framework, package references, project structure and all source files. Native preview users can also select and read project files or export the same complete archive.
These projects run with a desktop .NET 10 SDK. They do not run inside the SharpRune console runtime. Open C# practice loads the separate portable companion program into the .NET 9 playground or native editor. That companion explores a specific rule without starting Kestrel, opening SQLite or deploying a cluster.
The architecture course includes real multi-project solutions and project-reference checks. The load course provides bounded loopback experiments on one or two processes and Kubernetes examples for study. A local experiment is not a production capacity claim: choose a workload, record errors and tail latency, and evaluate shared dependency limits before increasing replicas.
Debug C# console source in the native preview
TestFlight build 17 includes a C# console-source debugger on iPhone and iPad. Open a console project and choose Start debugging in the editor or Debug panel. The first pause happens before the first executable statement, so a variable declared by that statement does not have a value yet. The browser playground retains Run and compiler diagnostics without source stepping.
Try the small program below. Step Over the first statement to assign amount, then Step Into the Double call to inspect its value parameter. Step Out returns to the caller; before Console.WriteLine executes, total is 4. Continue allows the output to be printed.
var amount = 2;
var total = Double(amount);
Console.WriteLine(total);
int Double(int value) => value * 2;Breakpoints, stepping and pausing
Tap a source line number to add or remove a breakpoint. A request on a blank or comment line binds to the next executable line in the same file when one is available; a request beyond executable source can remain unbound. Continue runs until a breakpoint or the end of the program.
Step Into follows project C# calls. Step Over executes the current statement without entering its calls. Step Out resumes until control returns to the caller. Pause requests a stop at the next instrumented statement, so an opaque library call may need to finish first. Stop ends the session.
Source remains read-only while debugging. Stop before making changes and start a new session to run the edited version. This preview does not provide hot reload.
Inspect values and the call stack
The current source location is highlighted before its statement executes. The Debug panel shows available assigned locals and parameters. Class instance members can expose their receiver through this; field and array values can be expanded. Select a call-stack frame to inspect its available values and navigate to its source.
The inspector reads fields without invoking user property getters or custom ToString methods. Ref-like values are omitted. There is no arbitrary watch-expression evaluation or variable-editing console in this preview.
Source debugging is for native C# console projects. .NET framework and package internals, expression lambdas and iterator bodies run as opaque calls. Server projects and JavaScript are outside this debugger feature.
What runs here
The public playground compiles C# with Roslyn and executes it in a .NET 9 WebAssembly worker. It supports the browser runtime and references bundled with SharpRune. It is useful for console programs, LINQ, managed data processing and many small language experiments.
It does not provide arbitrary NuGet restore, operating-system processes, a real TCP listener or desktop native libraries. A production ASP.NET Core application requires a separate server environment. The native app has additional project, package and preview features that are not all exposed by this public console playground.
Source in a normal local playground run is compiled in your browser. If your code itself makes network requests, those requests remain subject to browser rules and destination behavior. Do not put passwords, production tokens or confidential customer data into public examples.
Stop, errors and prepared input
Stop terminates the execution worker. A run also has a 120-second execution limit. Partial output may be lost on termination, and the next run starts a fresh worker. Prepared input is a fixed set of lines entered before running; this is different from an interactive terminal that waits for keystrokes.
A compiler diagnostic means the compiler found a problem in the submitted source. A runtime error means compilation succeeded and execution failed. A runtime load error means the browser could not start the toolchain; try reloading, checking the connection, or using a recent browser with WebAssembly support.
Keep your work
The browser editor is a temporary workspace. Download important code before closing or reloading the page. Lesson completion is local to the browser and can disappear when you clear site data, use private browsing, or switch devices.
In the native app, projects, lesson progress and settings live in app storage. Export projects to a location you control before deleting the app. Temporary relay rooms are not backups, and a room can disappear on expiry or a service restart.
Learning Unity with companion C# practice
The Unity6course includes actual Unity Editor scripts with filenames, scene or component setup and expected behavior. Those scripts use UnityEngine and require a configured Unity Editor project. They are displayed separately from the portable console exercises.
Open C# practice loads only the companion .NET console program. It explores the lesson’s C# logic without running a Unity scene or substituting fake engine APIs. On the website, Download Unity script saves the separate Editor file. The native app bundles both parts for offline reading.
Testing, I/O and Unity practice
The testing course uses executable C# checks to teach contracts, boundaries, controlled dependencies and regression cases. These console exercises do not replace a test project or test runner; the guides explain where framework-based unit tests and integration tests belong.
Streams and HTTP lessons run against in-memory data and explicitly supplied HTTP handlers. They exercise actual .NET APIs without a public network request. Production transport, storage and integration behavior require checks in your own target environment.
The Unity course now contains 36 lessons. Advanced Editor scripts include exact setup requirements for 2D physics, animation, UI Toolkit and AI Navigation. The matching console programs test portable logic, not scenes or engine callbacks.
Practice a C# or .NET interview
The interview library connects questions to working lessons. Filter by coding, runtime or production engineering, choose a level and explain your answer before revealing the reasoning. Each answer includes key points, a common pitfall, follow-up questions and primary references.
Start a practice session to work through up to ten questions from your current filters. Questions marked for review come first; sessions rotate tracks and prefer different lessons when enough questions are available. You can skip a question and return to its full page for references and runnable practice.
Review again and Understood are your own assessments, not automated interview scores. These marks stay in the current browser or native device and do not mark lessons complete. Website and native progress are stored independently. All full question-and-answer pages remain readable without JavaScript; interactive filters, practice sessions and browser self-review require JavaScript.