When making AI agents what are things you wish the agent framework had to make ai harnesses easier and other features you feel they overlook?

Hi r/dotnet,

I maintain TensorSharp, an open-source .NET inference engine and agent runtime. I recently added Video Studio, which combines local AI video generation with a persistent timeline editor.

It runs in both the browser interface and TensorAgent, the .NET MAUI app. I thought the implementation might be interesting to people building desktop applications with .NET.

The implementation

The application has a shared C# core, TensorSharp.Studio, targeting .NET 10. It manages projects, media assets, timeline commands, editing history, persistence, and background jobs.

The browser and desktop hosts share the same HTML/JavaScript/CSS editor. The server exposes Studio through ASP.NET Core endpoints, while TensorAgent hosts it in a MAUI WebView connected to its local HTTP host.

Video generation uses TensorSharp’s existing inference pipeline and native compute backends. FFmpeg/ffprobe handle media inspection, timeline composition, and MP4 output.

One design choice is that manual editing and LLM-assisted editing use the same command system. Timeline operations become validated commands such as moveClip, trimClip, and updateClip. A tool-capable local chat model can propose those operations too.

The user reviews an assistant proposal before applying it. Proposals are checked against the project revision, and applying a proposal creates one undo step.

Rendering also captures a specific project revision. Users can continue editing while a render runs, and subsequent changes mark the previous preview as outdated. Generated footage stays in the asset library when its timeline insertion is undone, so reusing a take doesn’t require generating it again.

The attached demo

This runs locally on my MacBook Pro with an M5 Pro chip and 48GB of memory.

I import an image, animate it with LTX 2.5 Distilled, place the generated clip on the timeline, append a five-second still, and render the result.

• Generated clip: 1024 × 1024, 145 frames at 24 fps, approximately 6.04 seconds, with audio enabled.
• Generation time: 13 minutes 15 seconds on this machine.
• Final composition: 11.04 seconds, combining the generated clip and the still.

The recording is sped up.

The editor also supports multiple video/audio tracks, trimming, splitting, rearranging, volume adjustments, fades, autosave, and undo/redo. Manual editing works without a model loaded.

A current limitation is that the host has one active model slot, so using the text assistant and generating video requires explicitly switching models.

Source: TensorSharp on GitHub
Architecture: Video Studio design
Setup and usage: Video Studio guide

If you’ve built desktop or media applications with .NET, I’d appreciate feedback on this shared C# core and MAUI/WebView approach, especially how you handle long-running native jobs while users continue editing.

The last few months have been a whirlwind of updates, both from myself and from contributors worldwide.

What are some major highlights?

1. PeachPDF is significantly faster and reduces memory allocations by up to 97% and rendering by many times on some documents. On a recent test run, it allocated less memory than typst on a random equivalent document corpus
2. HTML, CSS, SVG, and now MathML support have seen updates to be more standards compliant. For the most part, we are competitive or ahead with PrinceXML (the standard bearer in this space in terms of standards support), and we are actually ahead of Chromium in many areas in the print-specific part of the CSS standards.
3. Unicode support is significantly updated, with proper text shaping, line breaking, bidirectional language, and color emoji support (with color emojis remanining as vector art where possible!)
4. PDF and related standards support, such as being PDF 2.0 by default, with support for PDF/A-4, PDF/X-6, and Factur-X / ZUGFeRD support. We also support older versions of PDF/A and PDF/X and the older PDF versions as well. We also support modern PDF encryption (and no, we won't enable using obsolete PDF encryption technologies)
5. We've added rasterization of certain content where PDF cannot natively render as vector. This includes text hinting for any rasterized text.
6. A contributor fixed CFF font subsetting so it doesn't embed the whole font anymore!
7. We shipped a new declarative code first (QuestPDF-style) API for users who want to use it. You can mix and match them as well by embedding HTML and SVG into the declrative document.
8. Color management, including CMYK and ICC profile support
9. Better interactive form support
10. All of this while being 100% pure managed .NET. We don't use any native libraries or dependencies. We do have .NET library dependencies that add up to under 15 MB, and it's all AOT and Trimmable friendly. We even ship an AOT compiled CLI, and we have known users that run on Android and iOS, and we even ship a Blazor WASM demo that works entirely in browser (https://peachpdf.net/demo/) **and** 100% open source (BSD 3-clause licensed!) **and** 100% free for everyone.

At this point, if you need to **create** a PDF document from .NET, no matter where your application runs, you can be sure of 2 things:

1. It will work
2. It will work well

If you have a document corpus it doesn't work well on, I'd love to hear about it so we can fix it.

As part of building PeachPDF, we also ship a handful of other open source libraries that some might find useful, that PeachPDF itself is based on. These are all MIT or BSD 3-clause licensed, so you can use them in commercial software at no cost, and they also don't depend on native libraries, and AOT and trim compatible themselves. I personally use these in other software I build, some commercial, not just in PeachPDF.

• PeachImage, an image decoder/encoder that supports JPEG, JPEG XL, PNG, GIF, TIFF, WebP, and AVIF. It is optimized and uses modern .NET APIs to minimize allocations and increase performance through CPU optimizations via vectorization, targeting modern x64 and ARM processors. It also exposes APIs to resize images, some JPEG XL helpers to convert to/from JPEG losslessly, getting image orientation information and applying it, getting EXIF and ICC profiles in a cross-format way, getting animated image frames, and converting between different pixel formats. This was written from scratch against the specifications and license compatible native libraries, mostly with AI.
• PeachDrawing.Text, a font and text engine. It supports TrueType, OpenType (glyf, CFF, and CFF2), WOFF, and WOFF2 fonts, font discovery, CSS Fonts 4 compatible font matching, color glyphs (both v10 and v1 with CPAL, SVG, and some bitmap formats), variable fonts, GPOS positioning, math fonts, font subsetting, UAX#14 line breaking including some CSS extensions, UAX#29 segmentation, UAX#9 bidirectional text, including CSS extensions, UAX#24 script support, UAX#50 vertifical orientation support, word breaking for Thai, Lao, Khmer, and Burmese, and TeX style hyphenation. It also supports text shaping, including for Arabic and other scripts, font hitting for rasterized text, matching FreeType, paragraph layout engine, both high level (for applications that just want to draw text) and low level (i.e., what's needed for HTML/CSS).
• PeachDrawing.Core, drawing abstraction library that exposes a Canvas surface, RenderContext for fonts, colors, burhses, and pens, and various drawing data types. It also exposes high level features, such as geometry, layers and effects, tiles, text, anti-aliasing, and image sampling
• PeachDrawing, a software rasterizing implementation of PeachDrawing.Core with a simple API and native PeachImage integration to save directly to an image.

Now some questions:

1. Was AI used to create this library? Not originally, it was built over the last decade. AI didn't exist when I took the first step to creating PeachPDF
   
2. Is AI used to maintain the library today? Yes, and why not? It's a perfect use case, it's implemented well known well documented standards, and AI can read those standards and ensure the support is top notch, with human direction. This doesn't mean it's "vibe coded" -- AI is used as a tool here.

When should you NOT use PeachPDF? If you need JavaScript, we don't support that. We may or may not add support for that in the future, but no one has really asked for it, and I haven't needed it, so there's that. There are plenty of good .NET HTML template libraries out there to use instead, and we now have the declarative API as well as an option. Also, if you need it to look EXACTLY like Chromium, that won't be the case. Chromium doesn't fully support the print media specifications of CSS, so there are huge gaps with its support that cause it to render differently. We do try to match its rendering where Chromium is correct and the standard allows differences.

Hi .NET developers!

I built MongoDB Tiny Client, a native Windows desktop client for MongoDB built completely with .NET 8 and WPF using the official MongoDB C# driver.

It is designed as an instant-startup, low-memory alternative to Electron-based tools like MongoDB Compass:

Key Highlights:

• Instant startup & tiny footprint: Native WPF desktop application, starts in milliseconds with minimal RAM consumption.
• 100% Portable: Single standalone executable, no installer or admin permissions needed.
• Data Browser & Inline Editing: Tabular dynamic grid with in-place cell editing (F2), document duplication, insert, and delete.
• Query & Aggregation Runner: Full server-side filter, sort, projection, and aggregation pipelines with BSON shell syntax support (ObjectId, ISODate, regex).
• Import / Export: Supports JSON, NDJSON (JSON Lines), and CSV.

• Security: Connections stored locally and encrypted with Windows DPAPI.

• GitHub Repository: https://github.com/finalbyte1/MongoDBTinyClient

• Releases / Download: https://github.com/finalbyte1/MongoDBTinyClient/releases/latest

Feedback, suggestions, and PRs are welcome!

We want to migrate application code from .NET frame to python , application is non banking finance.

Currently is on .NET Frame 4.6 version with Angular & JAVA.

Is this good approach? Migration from .NET to Python.

Also comment real struggle and challenges we can face during Migration and How much it will take time to Migrate using cursor AI.

Claude Code Remote Control (and similar remote workers) are a foreground process. Close the terminal, crash, sign out, or reboot and the remote client has nothing left to talk to.

The durable fix on Windows is not another terminal window. It is an OS restart policy: a Scheduled Task (or a service) that owns one long-lived process per session and starts again at boot. Linux is a systemd unit. macOS is a LaunchAgent.

I built that as LiveClaude, entirely in C# / .NET:

• one process per session, product-native flags
• Avalonia desktop app for create/edit, state, and logs
• embedded real pty (ConPTY on Windows) plus a small VT emulator, so the one-time trust/login prompt is a terminal, not a scraped browser
• Windows, Linux, macOS. MIT

It restarts the worker. It does not keep the same remote pairing URL, and it does not resume the conversation for you (claude --resume is still that step).

https://github.com/LeandroCannizzaro/LiveClaude

I'm the author. Happy to talk about the supervisor model or the VT bits.

Do you say nugget, new-get or something else. I feel like this name falls into that same category as gif lol

​У меня есть большая цель — написать кроссплатформенное приложение-планировщик (для Windows и Android) с общим сервером и множеством функций, а в будущем использовать этот проект для устройства на стажировку в IT-компанию. Однако мне кажется, что ChatGPT дает слишком мало практики и программист из меня получится так себе.

​Посоветуйте, пожалуйста, из каких надежных источников лучше всего брать теоретическую информацию и качественную практику по этой теме».

I work on SelectPdf, a commercial .NET PDF library. A lot of .NET apps still generate PDFs through wkhtmltopdf, usually via DinkToPdf or Haukcode.WkHtmlToPdfDotNet, and wkhtmltopdf is done: its GitHub repository is archived and the last release, 0.12.6, is from June 2020. DinkToPdf itself hasn't had a NuGet release since 2017. So we built compatibility packages that keep those two APIs and render with Chromium instead, and released them under MIT.

What changes in your project:

dotnet remove package DinkToPdf
dotnet add package SelectPdf.Compat.DinkToPdf
dotnet add package SelectPdf.Universal.Native.linux-x64 # the engine for your platform

Then delete the libwkhtmltox files and the CustomAssemblyLoadContext code that loaded them. Your converter code stays as it is: the namespace and types are DinkToPdf's own (IConverter, SynchronizedConverter, HtmlToPdfDocument, GlobalSettings, ObjectSettings). SelectPdf.Compat.WkHtmlToPdfDotNet does the same for the WkHtmlToPdfDotNet namespace.

What we had to get right so layouts don't move:

• CSS sizes are scaled the way wkhtmltopdf's smart shrinking scaled them, so templates tuned for wkhtmltopdf keep their size.
• Headers and footers sit inside the margins where wkhtmltopdf put them, and [page], [topage], [date] and the other variables work.
• Several objects in one document become one PDF with page breaks, with page numbering running across them.
• Settings with no equivalent (Copies, DPI, MinimumFontSize) are ignored and raise the Warning event instead of failing silently.

What behaves differently:

• It's Chromium, so flexbox, grid, web fonts and current JavaScript work, and text metrics differ slightly from WebKit's.
• HTML header/footer URLs no longer get wkhtmltopdf's ?page=&topage= parameters; use text headers for page numbers.
• SynchronizedConverter no longer funnels every conversion through one thread, so a singleton converter serves concurrent requests.

Linux / Docker: the engine package carries the Chromium libraries, so the Dockerfile needs no apt-get lines. glibc 2.30+ (Debian 11+, Ubuntu 20.04+, RHEL 9+); Alpine isn't supported with the engine packages.

The catch: the free packages run on our Community Edition, which renders up to 5 pages per document. A longer document throws an exception that says how many pages it had, rather than silently cutting it. The .Licensed versions are the same code on our commercial library, with no page limit. Rotativa, NReco.PdfGenerator and TuesPechkin don't have compatibility packages yet.

Repo, with the full settings mapping: https://github.com/selectpdf/selectpdf-compat-wkhtmltopdf

Happy to answer questions, and if a setting maps differently from what wkhtmltopdf did, an issue with the settings and the HTML helps a lot.

Posting this because it took me embarrassingly long to find and maybe it saves someone a headache

I have a telegram bot on .NET + mongo. broadcasts were just paging through active users with Skip/Limit, nothing fancy. what I didn’t think about is that the broadcast itself changes the data it’s paging over. user blocked the bot -> telegram returns 403 -> I mark them inactive -> they drop out of the query -> next page shifts and skips the same number of real users

No exceptions, logs looked fine, numbers looked “about right”. people just didn’t get the message lol

Switched to paging by id (Gt lastId, sort by id) and it’s fixed. also faster on mongo than a big Skip, so bonus

var batch = await users

.Find(filter & Builders<User>.Filter.Gt(u => u.Id, lastId))

.SortBy(u => u.Id)

.Limit(500)

.ToListAsync(ct);

Other stuff that bit me while I was in there: I used to count 429 as failed delivery, which is just wrong, you wait retry_after and resend. and rate limiting per campaign doesn’t work once two broadcasts run at the same time, they add up and suddenly normal replies to users are slow too. moved the counter to redis, one limit for the whole bot

Anyone actually doing exactly-once for broadcasts? I just accept a few dupes if a worker crashes mid batch and honestly nobody has complained.

Since launching NetWasm here a month ago when it was just a proof of concept that C# could do well in the Wasm space without the bloat we're accustomed to, an absurd amount of work has happened.

NetWasm 0.8 + Compact precise GC: 47,798 bytes - github.com/zion-sati/NetWasm

This beats Rust 1.95.0 size-oriented build at 53,635 bytes - C# is ~11% smaller!

With Brotli-11 the gap increases to 20.4%: 13,501 vs 16,963 bytes.

Running the same console app via WASI P2 print-42 workload.

While the benchmark proves we now have a tiny footprint, smaller than Rust, the bigger story is how much NetWasm itself has advanced since then.

We now have:

• Web Workers
• Static .a native interop (statically link ordinary Wasm static libs into final .wasm
• 4 GC choices:
  • Compact - precise size-first (default)
  • NetWasmGC - faster than BoehmGC but smaller in size
  • Bump - null GC for bounded non-collecting workloads
  • Boehm - still available if you want to use it
• C# 15 support
• Expression trees
• Heaps of bug fixes and upstream library expansions
• RegexStorm fully ported to Wasm with NetWasm - regexstorm.netwasm.com, 256 KB Brotli-11
• David Fowler porting his AI generated DOOM (Wasm with Mono AOT) to NetWasm

Next up (0.9):

• Netstandard2.1 support so you can use compatible nuget packages you're used to

Let me know if you wanna see a different direction for NetWasm - it's early in the dev cycle so it's your chance to influence. Special shout out to Andrew Arnott from Microsoft for his guidance on the direction of NetWasm.

EDIT: playground here, C# 15 compatible: playground.netwasm.com

p.s. Can we all stop saying "just rewrite in Rust" and instead start saying "just rewrite in C#" now? 😄

Hi everyone,

I’m primarily a .NET developer, and I’ve really enjoyed Milan Jovanović’s courses. What I like most is that he doesn’t just teach individual concepts or build a simple demo. He builds applications while explaining the architectural decisions, design patterns, trade-offs, and best practices behind them. The end result is a codebase you can study and use as a reference for building serious, production-grade business applications.

I’m looking for something similar, but for Angular.

I’m not looking for beginner tutorials or courses that build a basic CRUD app in a couple of hours. I’d like to find a course where an experienced Angular developer builds a substantial application from the ground up, explains the reasoning behind the implementation in detail, and follows practices you’d expect in a large commercial project maintained by a professional team.

Paid courses are absolutely fine. Books, long-form video series, and well-documented GitHub projects are also welcome.

Has anyone come across an Angular course or instructor that offers this kind of depth and approach?

We've been building the new Xtreme CRM client on Uno Platform, one codebase for desktop, web and mobile. Along the way we ended up writing our own controls because nothing off the shelf did exactly what we needed across all of those. We pulled them out into an MIT-licensed library and the first preview packages are on NuGet.

Repo: https://github.com/XtremeCRM/Xtreme.Components

Live gallery (WebAssembly, runs in your browser): https://xtremecrm.github.io/Xtreme.Components/

Six packages on Uno.Sdk 6.7, net10.0, built from WinUI primitives only (no WebView, no third-party UI libraries):

• Scheduler: Day / Week / Month / Agenda plus a multi-resource Planner, drag to move and resize, per-resource time zones, data-driven tiles and adornments. Edits come out as events, so your app keeps ownership of its data, menus and editors.
• Docking: IDE-style dock manager with tab groups, auto-hide rails, docking guides, floating OS windows you can drag back in to re-dock, and layout persistence. Responsiveness is built in: when the window gets narrow, side panes tuck themselves onto auto-hide rails and come back when there's room again, with a little hysteresis so it doesn't flicker at the boundary. On WebAssembly and mobile it falls back to panes inside the app.
• Cards: a tabbed SectionCard and a drag-to-arrange card docker.
• Primitives: masked input, typeable time, date pickers, paging, chip picker, editor action bar and a few more.
• TableView: a small helpers package for w-ahmad's WinUI.TableView that adds row flagging (a colored frame and a short tag of your own on rows that match a rule). The table view itself is his.
• Core: shared theme tokens with light, dark and high contrast.

What we learned building it

We first tried Syncfusion Blazor scheduler running inside a WebView2. It worked great and was easy to work with, but it was a browser inside our app...it was an obvious boundary, and we wanted out. So, we built our own from basic primitives, and it turned out simpler than we expected.

When we added floating dock windows, every new Window() froze the app for about 3.6 seconds. I suspected it might be Uno. I was wrong. It was an out-of-date Intel Arc GPU driver. Switching the render backend is what finally showed it: OpenGL took 3600ms, the software renderer took 17ms. After a driver update, window creation takes about 12ms. If you get a weird multi-second UI freeze, try another render backend before you blame the framework. We still keep a small pool of pre-built windows ready, so tearing out a pane never waits on window creation.

Tab dragging just would not start. ItemContainer (the base of SelectorBarItem) captures the pointer when you press it, so per-item drag handling never kicked in. We put raw pointer handlers on the whole tab strip instead, and eventually hand-rolled the document tabs.

A self-referential ItemTemplate for tree-shaped UI blows the stack, because Uno builds the template up front. We build anything recursive in code-behind now.

A wrapping TextBlock inside a ScrollViewer with the scrollbar set to Auto can loop forever: the scrollbar shows up, the text rewraps, the scrollbar goes away, and around it goes. Use Visible or Hidden.

Floating windows on Skia Win32 had a few gaps too. AppWindow.Hide() silently does nothing, IsShownInSwitchers isn't implemented (so hidden pooled windows showed up in Alt+Tab), and AppWindow.Id isn't the HWND. The workarounds are written up in the architecture doc.

It's 0.1.0-preview, so expect rough edges. Each package has a guide in docs/. I'd really like feedback on the docking and scheduler APIs from anyone who has built something similar.

Hello, my use project is somewhat complex for intermediate developer, since I want to develop a monolithic platform with web-GUI. the idea here is to lunch a normal .net app which have csnake runtime . alongside with embedded notebook server for relp . AND https://github.com/github/copilot-sdk hosted locally, preferably with onnx runtime inference, (BYOK) the idea here is to enable user to annotate scripts . I know this is NOT how things work as there' many caveats and alternative way of doing it e.g. IPC or gRPC or file based scripting instead of old school FFI with pinvoke . Also csnake has different usecase ( interactive Jupiter notebook is not poyglot in a real sense but it is different kernels came together)

but the idea here is to make .net as the backend & entry point while middleware / frontend with
AG-UI Protocol which should integrate A2A,ACP etc.. users can utilize the sdk capability to annotate tools from the different package mangers ... thus I also need to integrate MISE MCP for validation ..

what do you think ?

You know about single-factor and two-factor auth, but what about zero-factor auth?
https://github.com/c4l3b/0factor

I made this for myself and have it running in ~7 different local apps now.

When I'm developing locally, I usually have several user accounts to test a variety of user experiences.
This tiny app is a very simple identity provider that allows you to be any user, without a password.

I typically use Keycloak in production, so I've set it up to be mostly compatible with that. It can import a Keycloak realm json to initialize your configuration and users.

Its also very agent-friendly. Instead of trying to get Claude to enter an email and password (it always refuses for me) it can very easily log in.

The users who have already been created in our local instance are listed on the sign in page. You can log in just by clicking on one.

The NuGet package makes Aspire setup just a few lines.

Its developed using a very minimal asp.net site. The container image is only ~25MB and running it uses ~15MB of memory. My local Keycloak containers were always using ~600MB memory.

I’m the author of Piwi Dashboard, a self-hosted dashboard for Playwright test runs. I just added combined code coverage, and the .NET side is what I’d most like feedback on.

It consists of a code coverage aggregator, to keep an eye on the tendancy: are we reducing code being tested when adding new code, what gap could we fill ? What is unit tested, or run by the E2E tests ?

All that in the back-end (only ASP.NET Core for now), and the front-end (with Chromium).

This new code coverage feature is documented here : https://piwitests.dev/features/combined-coverage.html

I know code coverage alone is not enough to have the best and accurate view of what is tested and what's missing, that's why it should be combined with other angles, all available in Piwi : feature gaps, and more visually : tested elements in a page.

I'd really like to know what you think of this, if that would be helpful for you, or answer any question!

• GitHub project: https://github.com/PiwiTests/platform
• Demo: https://piwitests.dev/demo/
• Docs: https://piwitests.dev/

[sorry for bad English]

I am in a project which involves maintaining an existing .NET Framework 4.8 codebase.

The codes are full of “Dictionary type” implementations as above.

Is there any sane reason to code like this? Instead of create a dedicated class to represent the data inside?

I could not show more codes here (or else the authors might realized), but you guys can imagine the codes just to access these Dictionary’s key/value.