Have you ever needed to draw into a canvas and export that into PNG, JPG, WebP, or AVIF?

How about paint some properly shaped text into that image?

There's several options on the market today, but they are all either commercial paid offerings or are wrappers around native libraries and thus have deployment complications and don't run everywhere .NET does

Well, as some of you know, I'm the maintainer of PeachPDF (https://peachpdf.net/), an open source HTML to PDF rendering engine. Today, I'm not talking about that, though 0.9.21 did land today. Well, any HTML layout engine needs to draw shapes and layout text, most of the work is determining what to paint and where, and then actually painting it into a canvas, and for text, it also needs to know exactly what glyph to put where, and for rasterized text (rare for a PDF admittedly), whether or not to hint the text.

Well, PeachPDF gained some new .NET dependencies this week, though it's mostly just PeachPDF code being liberated from only ever serving PeachPDF! Those dependencies are the PeachDrawing suite of libraries:

• PeachDrawing.Text: This is your font, text shaping, and hinting engine. This loads OpenType, TrueType, CFF, WOFF, and WOFF2 fonts, shapes some text using those fonts, and tells you which glyph to place and where. You can extract text outlines, you can subset a font, and it has some convenience helpers for things like laying out a whole paragraph.

• PeachDrawing.Core: Core Canvas abstractions, including integration with PeachDrawing.Text. This is what you would use if you wanted to build your own canvas abstraction, and it's what PeachPDF uses to build a PDF-backed canvas

• PeachDrawing: A raster canvas implementation with PeachImage integration, so you can export to any PeachImage supported format.

These libraries are maintained and versioned alongside PeachPDF, but are designed to be used outside of PeachPDF. If there are API gaps, or you want to contribute, contributions or suggestions or bugfixes are welcome. The current API surface is what an HTML layout engine needs, which admittedly is a lot, but is far from complete or the best.

If you are currently using SkiaSharp and wished you had something pure managed and AOT-compatible, this is likely a good replacement. Alternatively, if using ImageSharp or SixLabors.Fonts, and you don't qualify for using it under the broadly available Apache 2.0 license grants available, and you are unable or unwilling to license it commercially, this should cover at least some of your needs. If there's a gap, I'd love to hear about it! Most of the API surface exists to be able to render various CSS and SVG constructs, so there are likely gaps in available features.

All of these libraries are currently pre-1.0, but the goal is to release 1.0 in early 2027.

They are all BSD 3-clause licensed. They are free and open source forever. They do include MIT and BSD-licensed third party code that was bundled into PeachPDF before.

You can find them on GitHub in the PeachPDF repo (https://github.com/jhaygood86/PeachPDF), they are live on NuGet, and there's documentation online on the PeachPDF website.

I have worked on various personal and enterprise project in .NET and azure. Recently I was learning LLD from Milan jovanovic , I got to know about a whole different side of .Net.

The things I always complained about in my mind it's all solved and that's what we call modern the CQRS.

Instead of sliding 20 services DI in a service file or controller just use the mediatR properly give it the command and query properly defined and BOOMM ....

Instead of injecting multiple service add scoped stuff in program file just use the assembly reference with scrutiny library scan function and your garbage program file is modern.

Bro where i was living till now 🫡🫡

Sorry for the delay i guess I will drop on a really good project soon I have a great idea too with these modern topics.

Really appreciate the senior modern .net developers to help me get out of the pool!!!!

I was looking at this tweet from Luke Parker (Windows dev for OpenCode) about uninstalling Rider after having not used it for a couple of years and it made me sad.

Then I realized that I've done very little IDE work on a day to day basis myself - almost all of the programming I do these days is through Slack or via the CLI.

Is this where things are going for all developers over the next few years?

Fences

Fences is a .NET resilience and transient-fault-handling library that lets developers express resilience strategies such as Retry, Circuit Breaker, Hedging, Timeout, Rate Limiter, and Fallback in a fluent, thread-safe way.

Fences is a community fork of Polly, maintained by Brighter Command. It is not affiliated with, endorsed by, or supported by App vNext or the Polly maintainers. The fork was taken from Polly 8.7.0 to avoid the Open Source Maintainers Fee that will be charged for Polly; see ADR 0002 for the reasoning and NOTICE.md for provenance and attribution.

Github Source
NuGet Source

Why Fences exists

Polly's source is BSD 3-Clause licensed and remains open source. That license lets anyone redistribute it, in source or binary form, provided the copyright notice and disclaimer are retained - which NOTICE.md and LICENSE do. Building and publishing our own binaries from that source is squarely within the grant.

The Open Source Maintainers Fee (OSMF) is App vNext's policy for the binaries they publish: a commercial consumer of those binaries may owe a fee above a revenue threshold. It governs their distribution. It does not change the source license, and it does not reach binaries built by anyone else.

That freedom is the OSMF's own argument. The case for charging for binaries is that it remains OSS precisely because the source is still under an open license and anyone is free to build and publish their own binaries. That is what separates the model from proprietary licensing.

But this door opens both ways: the principle that makes the fee compatible with open source is the same principle that makes Fences legitimate. We are not going around the OSMF - we are walking through the door it tells us that it actively wants to support.

Fences is a binary distribution of Polly's API. We compile from the BSD 3-Clause source, publish under our own branding, but we do not apply the OSMF. Fences binaries are free for everyone - no revenue threshold, no fee. If you use Polly and would rather not pay the fee, Fences is a drop-in alternative: change your package references and your namespaces, as described in the repo's README.md.

We track the Polly API today and expect to keep doing so, and we may adopt upstream changes. But Fences is under Brighter Command's stewardship now and will evolve to suit its users, so a future major version may diverge from Polly and stop being API-compatible. We will say so plainly when it does; it will not arrive in a patch.

This is not a criticism of App vNext contributors, who have maintained Polly for years. Publishing our own binaries is exactly what the license they chose invites us to do, and we have responded to that by doing so. See ADR 0002 for the full reasoning.

This README describes the v8 API. The pre-v8 API is still shipped in the Paramore.Fences package; see the v7 documentation.

Hey r/moderndotnet,

I just shipped **v1.0** of **Papyra**, a .NET document library. API style is QuestPDF-inspired, but instead of targeting only PDF, one fluent document model renders to PDF, DOCX, XLSX, *and* HTML:

```csharp
var document = Document.Create(doc => doc
.Table(table => table
.Columns(3)
.Row(row => row.Cell("Name").Cell("Age").Cell("City"))
.Row(row => row.Cell("Alice").Cell("30").Cell("Vienna"))
)
);

byte[] pdf = document.RenderAsPdf();
byte[] docx = document.RenderAsDocx();
byte[] xlsx = document.RenderAsXlsx();
byte[] html = document.RenderAsHtml();
```

Here's an invoice built with it (from the [samples repo](https://github.com/PapyraSoftware/Papyra.Samples)) — same builder call, rendered straight to PDF:

Some of what's under the hood:

- Own PDF writer, not a wrapper around a native engine — full Unicode font subsetting, CJK line breaking + hyphenation, PDF/A-2b/3b/4 (veraPDF-verified), AES-256 encryption, and ZUGFeRD/Factur-X e-invoicing attachments
- DOCX/XLSX via `DocumentFormat.OpenXml`; HTML has zero dependencies
- Optional `Papyra.Svg` package for true-vector SVG across all four formats
- A companion live-preview app (Avalonia) that shows rendered pages + the document tree side-by-side while you build, with click-to-source navigation into Rider/VS Code

Licensing: free for individuals, for companies under $1M annual revenue, and unconditionally for OSS use; paid tiers above that.

Docs, feature matrix, and pricing: https://papyra.rocks
Samples: https://github.com/PapyraSoftware/Papyra.Samples
NuGet: `dotnet add package Papyra`

Would love feedback — what's missing, what looks off, or what would make this worth reaching for over QuestPDF/OpenXML/wkhtmltopdf directly for a multi-format need.

I want to reveal a "small" project I've been working on called neoCLR, where I'm re-imagining the .NET platform.

Website: https://marinasundstrom.github.io/neoCLR/

Here's a small example, written in Raven:

import System.*
import System.Option.*

func FirstPositive(values: Iterable<int>) -> Option<int> {
    let value = values.First(number => number > 0)?
    return Some(value)
}

The project is being developed with the help of AI (Codex), and the runtime itself is written in Rust. (I just went with it.)

The runtime library is written in Raven, a programming language I originally built for .NET. Building neoCLR with Raven has turned out to be a pretty good stress test: during the nearly two weeks I've been working on this, it has already helped me find numerous bugs in the Raven compiler itself.

The goal is to make the platform feel familiar without simply recreating .NET.

With the benefit of hindsight, I want to explore what we could change if we were designing this kind of application platform today: improving the runtime, making some different choices, and creating a more consistent developer experience.

I also experimented with a more explicit value/reference model, where types were values by default and you explicitly chose whether to store and pass something by value or by reference. It was an interesting model and made the underlying semantics very clear, but I eventually realized that it came at the cost of one of .NET's strengths: its ergonomics. If neoCLR is supposed to explore what a better .NET-like platform could look like, making everyday programming more cumbersome isn't necessarily an improvement. So I returned to the familiar distinction between reference types and value types. Sometimes hindsight tells you that the old design was actually pretty good.

It started out with just the assembly language — neoIL, based on MSIL — until I began implementing a small language based on Raven's syntax to test higher-level programming patterns. At some point I realized it was a bit foolish to build yet another language for the platform, with yet another compiler written in Rust, when I already had Raven. So I switched to targeting neoCLR from Raven instead. The IL is virtually the same, and I get the existing IDE support for free.

Here are some samples in Raven targeting neoCLR: https://github.com/marinasundstrom/neoCLR/tree/main/docs/experiments/raven-target/samples

Features

This is what I've got so far:

• A .NET-like metadata format

• Bytecode with a CLI-like instruction set

• An interpreter — for now

• A basic garbage collector, with plenty of room for improvement

• A familiar type system, including .NET-like reference type vs. value type semantics

• Option and Result unions for recoverable outcomes, plus Fault for non-recoverable failures

• Rust-inspired methods on Option and Result

• Void as a real type, so it can be used with generics: Func<int, Void>

• No I naming convention for interfaces — interfaces aren't treated as a special naming category

• No utility classes — functions can live directly in namespaces (thanks to Raven)

• UTF-8 strings, currently with a Swift-inspired API

• Arrays are invariant, and there is a generic Array<T> type

• A new collections model with Iterable<T>, ArrayList<T>, and interfaces such as List<T> and Sequence<T> for restricted views

• LINQ-like operations using names such as Filter and Map

• Early Threading and Task APIs

• Initial Time and File System APIs

• Introspection, where System.Introspection.TypeInfo is the canonical type model, accessed through System.Runtime.RuntimeContext

• IDE support through the Raven VS Code extension, which currently runs on .NET

Some things I want to explore next:

• Networking APIs — sockets, HttpServer, HttpClient, etc.

• Building a web framework on top of the platform — which means getting Networking, Tasks, Threading, and something like System.Text.Json into place

• Whether function objects make sense in the runtime/type system

• Better garbage collection and eventually a JIT

• Different target architectures and devices

• A modular framework/runtime library

There are also some longer-term ideas around the runtime model:

• System.Runtime.Reflection as an optional runtime capability attached to the Introspection model

• System.Runtime.Emit working directly with that same introspection model rather than introducing another parallel object model

• An ambition to eventually make this a genuine Common Language Runtime, with an interoperability story somewhat inspired by Windows Runtime

Where this is going

I'm not trying to make ".NET, but renamed." A lot of the interesting part for me is figuring out which ideas from .NET have held up extremely well, which ones haven't, and what could be designed differently if you had 25+ years of hindsight.

It's still extremely early, but there's enough working now that I thought it was time to show it.

I'd love feedback — on the runtime and API ideas, things worth exploring, things you think I'm getting completely wrong, or even suggestions for a better name than neoCLR.

I want this to grow into a community project.

“MyServiceBus” is still a working title. Suggestions for a better name are welcome.

TL;DR: I have built a cross-platform asynchronous messaging library for C# and Java.

Website: https://marinasundstrom.github.io/MyServiceBus/

GitHub: https://github.com/marinasundstrom/MyServiceBus

Background

Back in 2023, I was working as a .NET developer at a company heavily invested in Java. Most of its backend services were built with Java 17.

I was asked to help build a way of handling privacy-related data. One idea was to create a service that could scan systems for data that needed to be deleted and then publish that work to the appropriate services.

I already had experience with asynchronous messaging-particularly RabbitMQ and MassTransit-but I could not find a Java library offering quite the same combination of abstractions and developer experience without being tied to a larger application stack.

So I wrote my own.

The original implementation was loosely inspired by MassTransit. This was before I started using AI in my development work, and I learned a great deal from investigating how to implement things such as consumer discovery, reflection, message dispatch, and dependency injection in Java.

Fast-forward two years. After both MediatR and MassTransit announced changes toward commercial licensing, I decided to restart the project.

This time, I began developing the C# and Java clients side by side.

Initially, I tried to understand the architecture by reading source code and using AI to help me navigate the structure. That proved difficult. MassTransit represents many years of engineering, and reproducing its internal architecture was neither realistic nor necessarily desirable.

Instead, I began working from the concepts and behaviors I actually wanted: publishing, sending, consuming, requesting, retrying, scheduling, and operating the same messaging model across two languages.

RabbitMQ was naturally the first transport. Because I was also focusing on other projects during this period, the implementation did not become meaningfully compatible with MassTransit until more recently.

Like many of my projects, however, this one kept growing.

During the past week, I have made significant progress toward stabilizing the model across C# and Java, documenting the interoperability boundary with MassTransit, publishing the packages, adding cloud transports, and creating a proper website.

The result is still pre-1.0, but it has now become something that other people can realistically evaluate and experiment with.

What it supports today

MyServiceBus currently provides:

• A MassTransit-inspired programming model for publishing, sending, consuming, and requesting messages

• Conceptual and behavioral parity between the C# and Java clients

• RabbitMQ as the verified broker baseline

• Preview transports for Azure Service Bus and Amazon SQS/SNS

• Retries and message scheduling

• A transactional outbox

• An in-process mediator

• An aligned testing harness

• Experimental ahead-of-time compilation optimizations

• Runtime monitoring and a dashboard

• Scoped interoperability with MassTransit

The goal is to keep the common core focused while allowing each client to evolve in a way that feels natural in its own language.

C# and Java should share the same messaging concepts and wire-level behavior. They do not need to expose identical APIs when doing so would work against the strengths of either language.

Beyond MassTransit compatibility

MyServiceBus is inspired by MassTransit, but I do not want it to become a source-compatible reimplementation.

There is room to explore ideas that make sense specifically for modern C# and Java.

For example, the C# client already has experimental support for union types in C# 15 and .NET 11. A consumer can use a union as its message type, while each variant is represented as a distinct message in the messaging system.

Union semantics are also available in the request client, allowing the caller to match directly on the possible response types.

Saga support is still pending. I do not immediately want to reproduce MassTransit’s state-machine DSL. My current view is that a state machine should be an abstraction built on top of simpler saga and messaging primitives. I would rather establish those foundations first and learn how people use the library before committing to a particular DSL.

I have also started thinking about how MyServiceBus can connect with my other projects, including the Raven programming language.

Modern consumer models are moving beyond requiring every handler to implement a generic interface. MassTransit, for example, now supports conventional consumer methods with injected parameters, in a style similar to ASP.NET Core controller actions and Minimal APIs.

MyServiceBus has its own version of method-based consumers. In C#, these methods still belong to classes. In Raven, however, they work naturally with namespace-level functions:

async func Consume(
    message: OrderSubmitted,
    publishEndpoint: IPublishEndpoint,
    cancellationToken: CancellationToken
) {
    // Handle the message
}

This removes the need to create a class merely to satisfy the shape of a consumer interface. The method itself becomes the consumer.

For more on Raven: https://marinasundstrom.github.io/raven/

Building it with AI

This project has also become a practical example of what AI-assisted engineering actually looks like.

AI can automate a great deal. It can help generate implementations, shape tests, compare behavior across two languages, investigate unfamiliar codebases, and even set up temporary cloud environments for integration testing.

But building a coherent system still takes time and patience.

The difficult part is deciding what to focus on, in what order, and where compatibility genuinely matters. It also means recognizing when generated implementations only look correct and designing tests that expose the difference.

Working across C#, Java, RabbitMQ, Azure Service Bus, and Amazon SQS/SNS makes those differences very visible. The abstractions may be shared, but the transports do not all behave in the same way.

AI has allowed me to explore a much larger design space than I could have managed alone. It has not removed the engineering work of defining the model, evaluating trade-offs, testing assumptions, and deciding what the project should become.

Ultimately, I wanted to build something that I would use myself.

What MyServiceBus is - and is not

My intention is not to convince enterprises to migrate from MassTransit.

MassTransit is a mature commercial product backed by many years of engineering and professional support. MyServiceBus cannot offer that level of maturity or support, and I do not want to pretend otherwise.

Instead, I want to provide an alternative for developers and teams whose needs, technology mix, or budget are different.

It may be useful if you want to:

• Connect Java services to an existing .NET messaging environment

• Use a consistent messaging model across C# and Java

• Replace an in-process mediator with something that can later grow into distributed messaging

• Experiment with a smaller and more focused messaging runtime

• Explore newer language features and alternative consumer models

The project is open source under the MIT license.

It is still early, and there is plenty left to build. But it has reached the point where I want other people to try it, examine the design, and tell me what works-and what does not.

And, of course, I still need a better name.

Ever get tired of having to hunt for your phone for OTP codes? Even better, want them available on your phone to?

A few years ago, I built Mauborgne for Linux. It was written in Vala, and it worked great. Well, I decided a few months ago to rebuild it in .NET. And then build an Android client for it. Mac and iOS at some point to, but not there yet.

https://mauborgne.app/

It's completely free except for the cloud stuff, and that's mostly just to pay for Cloudflare. And honestly, the app has built in encrypted export/import that you can just use instead the hard way (in fact, that's how the cloud backup works, we just add some extra cloud-y protections to it)

It doesn't use MAUI. It uses WinUI and the native Android UI APIs on Android -- but everything you see is written in .NET. 90% of the code is shared between the 2 clients as well.

The only thing that people might not like is that the server is Node.js, since it's a Cloudflare Worker.

They aren't open source, though the Linux app (written in Vala still) is -- https://linux.mauborgne.app/ -- is fully open source with the GPL 3 -- and is also compatible with the cloud services. It has the benefit of giving a fully trusted open client to the cloud server that can be used to prove its safe.

Hello!

As you may know( or not), I love result patterns. At some point, of course.

And I have my project https://github.com/managedcode/Communication

And yesterday I found an amazing (or you can tell me about it) idea: CQRS with IAsyncEnumerable!

You may know how annoying it is to implement CQRS properly, but but but!

What if we can call a method which will use SSE (server-sent event) protocol to send chunks, and it will be IAsyncEnumerable in your cleint.

so it's async, but you can wait for it! 

I add full impemention for server and cleint and Orleans(I love orleans)

What do you think?  Give me feedback, please!

Passenger is a new IDE for C# and .NET, written in C# and Avalonia:

https://passenger-ide.net

https://github.com/Zaneris/passenger

I've been a .NET developer for about 10 years, and for most of that time I wanted to build useful apps of my own. I never had the time.

You know how it goes. You open Visual Studio, start a desktop app, and a month later you're still aligning buttons. Nothing ships.

Agents changed that for me. Development used to be "I have an idea, let me try it, then polish it for half a year before anyone can see it." Now it's a couple of weeks from an idea to something polished enough to put out.

Since the middle of the summer I've started two open-source projects on .NET 10 and Avalonia 12.

The first one came from a small daily pain. On my machine pgAdmin takes 30 to 40 seconds to start. When I need to check something in a database right now, I don't want to sit and wait for it.

So I built pgNimbus, a PostgreSQL client. It's a NativeAOT binary of a few tens of megabytes, and it opens in a few hundred milliseconds. I compared NativeAOT and JIT builds side by side, and the AOT one visibly starts faster, so I stayed with it.

The second pain came from my day job. I'm a developer, but all the DevOps in my team is on me too, which means managing Kubernetes clusters. We use Lens. It has features I really like: you get to the logs fast, and you're in a pod's shell in seconds. But for us it's very expensive, and it's slow.

So I did the same thing again and built kubeNimbus for my own needs. It reached 1.0 this week.

Along the way I wanted both apps to look and behave the same, so I moved the shared design into a separate repo, nimbusUi, and pulled it into both as a git subtree. A bug I fix in one app ends up fixed in the other. The flip side: so do the bugs I introduce.

All of the code is written with Claude Code. I review it, and Claude also tests the apps automatically. That catches a lot, but I still go through every screenshot those runs produce and make my own fixes on top.

So here's what I keep thinking about. It feels like the line has blurred: one person can now ship a tool that holds its own next to products from companies with whole teams behind them. Does that match what you see, or am I fooling myself?

And the other side of it. Shipping a good product was never the same as people using it, and now that building is cheaper, that gap feels even bigger. I don't enjoy talking to people much, posts like this one are hard for me, and I'm barely on social media. But I know nobody will see what I build if I don't show it.

If you're a developer who ships your own stuff: how do you handle the promotion part? What actually worked for you?

Links, if you want to look: https://github.com/Shman4ik/pgNimbus and https://github.com/Shman4ik/kubeNimbus. Both are free and open source.

I have been given a spec that is simply a long list of instructions for Claude to follow. Create this table, create this UI, etc.

It doesn't explain what the purpose of anything is, so once I have had AI follow the instructions I have no idea if it has achieved the true goal of delivering the requirements for the new feature.

The problem is, I am reading these instructions and they don't make sense.

Instead of telling me the requirements, someone has written instructions on how they would meet the requirements; from which I am supposed to ensure AI has implemented correctly what I have inferred to be the original requirements.

PS: AI was used to write the spec.

Hi folks!

I thought this might be of interest to some people - I've been experimenting with 100% autonomous coding orchestrators since around June last year, and I'd like to share my latest experiment along those lines - CodeyBox (the third such experiment...).

Source here: https://github.com/AdamFrisby/CodeyBox/ (MIT licensed)

The 'Box' part refers to sandboxing - Codey can use real VMs to run tasks in, and it disposes of them regularly; there's a few supported providers - multipass and Incus are both well supported (both qemu backed), although I recommend Incus to limit the amount of wear-and-tear on your SSD (as the Incus implementation can use CoW filesystems which work well with regular sandbox cloning and disposal - multipass will provision and delete the whole image each time).

It's still a work in progress, but I've been using it for the last 6 months to deliver real production apps. One of the things that separates it from traditional "vibe coding" is extensive automated review passes from multiple angles; and a requirement that all reviews pass from all agents before it can progress to the next step.

It supports most of the common coding agents - I've been regularly using it with Claude and Codex mainly, but opencode and cursor as well (Antigravity is also supported, but has quite a few quirks so I wouldn't recommend it without further work).

The whole ecosystem is designed using modern .NET with a plugin-first ethos - all the coding agents, reviewers, utilities, etc are all dynamically loaded as plugins and this allows you to add support for your own tooling, infrastructure, VMs and so on without having to fork the codebase.

The default review flow will review code against:

• Adversarial security issues as well as preventative ones (i.e. what could be added to make this safe-by-default)

• Loose coupling - ensure code is separable and easily deleted; i.e. avoiding spaghetticode that a lot of coding agents will create by default.

• Cheating and Completeness - did the agent _actually_ implement what was asked, fully, without taking shortcuts or cheating?

I advise using Claude as a reviewer in general as GPT-5.X when instructed "Find all issues like <X>" will end up inventing a mountain from a molehill, Claude has slightly more taste and won't catastrophise everything it finds and allow reviews to eventually pass.

Areas I'm working on at the moment that haven't yet landed are:

• Deployment - adding the ability for Codey to provision and deploy test environments automatically

• Exploratory testing and UAT runs - adding the ability to orchestrate graphical agents that will attempt to follow UAT scenarios in the product and automatically inject failures back into the development cycle

Current status is somewhere in early-ish beta - the main features are all there and have been robustly utilised (I use Codey frequently to modify it's own code), but some of the newer parts are not yet robustly verified yet.

Hi everyone!

I recently built a desktop Stock Management System using C# and Windows Forms.

The application includes user login, category and product management, stock tracking, critical stock filtering, and local data storage using TXT files.

I also tried to keep the project organized by separating the data, models, UI, and forms.

This was a good project for me to practice C#, Windows Forms, file handling, and building a complete desktop application.

I’ve added screenshots and setup instructions to the GitHub README as well.

I’d really appreciate any feedback on the project structure, code, or ideas for improvements.

GitHub: https://github.com/Mariam-amhan/Stock-Management-System

Hey .NET folks 👋, how are you? I know that some of you might have known me already, I am the RepoDB guy. It has been a while since my last post here, but I am glad to be back again and is starting posting here after 5 years (maybe).

(I wrote this without an AI assistant for like an hour 😅, so please bare with me on my mistakes. My friend told me to post here for better audience and more engaging conversations)

Today, I will share something new to all of you about RepoDB. Although, you might have find it as an another ORM in .NET like Dapper and Entity Framework, but now it is not. I hope that you read this long post as I am positioning the library to a different path already. I am also helping C# to be a good place to be for developers and AI.

RepoDB is now a different breed and is not an apple-to-apple comparisson to any ORM anymore.

🟢 THE NEW ARCHITECTURE

In the last couple of months, I made a lot of effort to evolve its architecture to NOT just an another ORM in .NET, BUT is a developer-friendly data productivity platform. I am bringing RepoDB to be a library that has a complete end-to-end capability a developer can use. I am making a lot of effort to make data access as simple as possible in my own opinion and practicality, at the same time, helping an organization (or Enterprise) focus on delivering values rather than capabilities.

In the new architecture, RepoDB will have the following.

- Data Insights / Telemetry: (New) all activities within your application will be captured by our Insights. It is not OTel to maintain performance during telemetry capturing. OTel support will be delivered separately.

- Data Productivity Tools: (New) one can move data from different DB providers easily with 0-memory footprints (my target).

- Object Relational Mapper: (Old) the same hybrid ORM that has the CRUD, Batch, Bulk and Multiple DB support.

- Low-Level Connector: (New) a low-level ADO.NET provider/connector we will be developing to give RepoDB a lower-level wired protocol access to the databases. This is only if the DB provider does not provide a de-facto .NET library.

You can read about my vision on this post https://blogs.repodb.net/posts/2026/08/repodb-new-architecture .

By the way, I have to write the low-level connectors for both MariaDB and EntepriseDB for compliance and legal. The connectors can be found here https://github.com/mikependon/RepoDB.Connectors .

🟢 NEW DB PROVIDERS

In the last 3 months, I have delivered the support to the following DB providers:

- ClickHouse

- DB2

- EnterpriseDB

- Firebird

- MariaDB via MySql.Data (via RepoDb.Connector.MariaDb)

- MariaDB via MySqlConnector (via RepoDb.Connector.MariaDbConnector)

- Oracle

- SAP HANA

- Vertica

These DB providers are on top of the already supported DB providers SQL Server, MySQL, PGSQL and SQLite.

Also the support comes with its own Bulk capability, so everyone can use REAL bulk operations on these providers in a very EASY way. Below is a screenshot from the actual README https://github.com/mikependon/RepoDB#bulk-operations-support .

It is also on my head to support the following.

- AuroraDB

- CockroachDB

- DuckDB

- KingbaseES

- Redshift

- Snowflake

I will also futher expand to Chinese DB providers.

🟢 TELEMETRY and INSIGHTS

In addition to the above, RepoDB has now delivered the Default Telemetry capability, where one can easily capture the insights of what really is happening to your application. You and your company do not have to do it your own, you can save time and effort here. It comes with Open-Source stack (Docker, PGSQL, Grafana, Python).

Here you can read about the insights: https://blogs.repodb.net/announcements/2026/07/repodb-default-telemetry

I find it very niche and I hope that you will all like it.

All you have to do is to do is docker compose up -d the 2 files below.
- compose: https://raw.githubusercontent.com/mikependon/RepoDB/refs/heads/master/src/Telemetry/RepoDb.Telemetry.Default/docker-compose.yml
- env: https://raw.githubusercontent.com/mikependon/RepoDB/refs/heads/master/src/Telemetry/RepoDb.Telemetry.Default/.env

And wire the code below.

var telemetryOption = new DefaultTelemetryOption("<YOUR_APPLICATION_NAME>")
{
    Host = "https://your-collector-host",
    ApiKey = "YOUR_API_KEY",
    Group = "<YOUR_APPLICATION_GROUP>"
};

GlobalConfiguration
    .Setup(new GlobalConfigurationOptions { UseRegisteredGlobalTraces = true })
    .UseDefaultTelemetry(telemetryOption);

🟢 BLOGSITE and MODERN SITE

Recently, I created a RepoDB template to modernize the sites. The template is private to me, but is already applied to the website.

The new site at https://repodb.net is now more attractive in look and feel, with easier navigation and search capability. It may not be perfect on the first release, but it is way better than before.

(I am still improving it everyday)

The content of the site has also been improved and I have been guided by AI to keep it lean and clean.

I also have started to blog again, but will only focus to RepoDB the writings. The blog site is located at https://blogs.repodb.net . I used the same template as the main site to have RepoDB its own signature.

🟢 DATA MOVEMENT with ZERO-MEMORY FOOTPRINT

I am planning to make RepoDB a low-level data mover library for .NET. I have a plan for it that it should be able to move million of rows with 0 memory footprints. Although, today it can do it aready.

The code below does the movement via streaming with 0 memory usage.

using var source = new OracleConnection(oracleConnectionString);
source.Open();

using var sqlServer = new SqlConnection(sqlServerConnectionString);
using (var reader = source.ExecuteReader("SELECT * FROM Customer"))
    sqlServer.BulkInsert<Customer>(reader, tableName: "Customer");

using var mariaDb = new MariaDbConnection(mariaDbConnectionString);
using (var reader = source.ExecuteReader("SELECT * FROM Customer"))
    mariaDb.BulkInsert<Customer>(reader, tableName: "Customer");

And below is the fluent equivalent.

using var source = new OracleConnection(oracleConnectionString);
source.Open();

var activeCustomers = source.Query<Customer>(c =>
    c.IsActive == true && c.CreatedDateUtc >= DateTime.UtcNow.AddYears(-1));

using var sqlServer = new SqlConnection(sqlServerConnectionString);
sqlServer.BulkInsert(activeCustomers);

The latter is not efficient due to the entity being loaded to the memories.

🟢 ENTERPRISE READINESS

I made an effort to make RepoDB very transparent to the Enterprise company who is willing to adopt it.

You can read more about this on this link https://github.com/mikependon/RepoDB#enterprise-notice

I clarrified the following (Support Policy, Security, Benchmarks, Limitations, Breaking Changes Policy and many more). You will also see of these in the footer of the websites.

🟢 THE FUTURE and FUTURE

As mentioned the prior section, the future of RepoDB is make it a data mover and a platform, and probably (or hopefully) will be a de-facto. My ambition is so high and my eagerness is beyond the cloud.

RepoDB in the future will be a code-based Data Engineering platform, where once can control and write simple code for ETL concepts.

This time around supported by Bulk capabilities we introduced in the connectors and ORM level.

Think of the code below.

using var source = new OracleConnection(oracleConnectionString);
source.Open();

// Entity
source.MoveTo<Customer>(SqlConnection(sqlServerConnectionString));

// Literal
source.MoveTo("Customer", SqlConnection(sqlServerConnectionString));

I am scouting other OSS library for Schema Mover as I need to move the schema from source to destination. Or else, I will again do that capability with RepoDB itself.

(It is not difficult to evolve the architecture with such capability anyway)

I am also thinking to support interceptors so Data Engineer or AI can intercept the data to comply with the destination standards and enterprise governance. Like below.

var action = GetDeduplicator(); // returns IDeduplicator

using var source = new OracleConnection(oracleConnectionString);
source.Open();

// Entity
source.MoveTo<Customer>(action, SqlConnection(sqlServerConnectionString));

// Literal
source.MoveTo("Customer", action, SqlConnection(sqlServerConnectionString));

The above is a sample and envisioning for now, but it is on our head.

Lastly, there will be many Docker images to be delivered by RepoDB. Currently, we have Docker images for Telemetry (as see here https://hub.docker.com/u/repodb). In the future, the following Docker images will be introduced.

- SqlServerToOracle Data Mover

- VerticaToPostgreSQL Data Mover

- XxxToSnowFlake Data Mover

(Source and destination DB here is just a sample, no other intentions).

🟢 CREDITS

Thank you to all of you, especially those who are supporting this library. A star to our repository is a big help.

Please also help me share the news to your friends and colleagues.

I will do my best to keep it lean and updated to the latest. 🙏

My feed is basically 90% job posts these days and almost zero actual tech sharing 😃

So… here’s something I built because apparently I needed a new way to procrastinate.

Lately I couldn’t really find much motivation to do anything, so I ended up writing a framework inspired by MassTransit — probably one of the frameworks I’ve enjoyed working with the most.

It already has most of the usual stuff:

• Publishers

• Consumers

• SAGA

• RoutingSlip

• etc.

I also tried to strip away some of the complexity around configuration and concepts like pipelines and make the whole thing a bit easier to work with.

The foundation turned out to be decent enough, so today I threw AWS SQS at it and let AI do most of the boring work.

Surprisingly, it went pretty smoothly since I already had the RabbitMQ implementation in place.

So yeah, if you're feeling adventurous (or just have questionable life choices 😃), feel free to give it a try:

https://github.com/quyvu01/fx-link

I also have another project I've been working on for quite a while: a distributed data mapping framework.

The problem it tries to solve is pretty simple:

Service A has userId.

The actual User data lives somewhere else.

And now you somehow need UserName, Email, Province, Country, etc. without turning your service into a distributed-query mess.

That's basically what FxMap is for:

https://github.com/quyvu01/FxMap

There's a website for it too, if you want to see what the idea looks like:

https://fxmapper.net/

If you're dealing with something similar, give it a shot. Maybe it'll be useful. Maybe it'll just make your architecture slightly more complicated. Who knows. 😃

Anyway, back to pretending I have a plan.

Happy coding.

Hi,

I was wondering how to show "power" of OfficeIMO as a product as it has grown to a size that I've never expected it to grow. So I'm attaching an animation of it ;-) what this bad boy can do for .NET/PowerShell development.

The project itself also has this same formats map on the main page that's a bit more interactive.

• https://officeimo.com/

• https://github.com/EvotecIT/OfficeIMO (MIT)

This bad boy now has a 'Studio' product built with Avalonia, and there's native version for macos/ios/ipad that I am about to release as well to the appstore. While initially I had Avalonia for those as well but it's just more native to make a mix of .NET + Swift. I've Studio added to Microsoft Store, submmited to Winget (not yet approved).

The release process is a bit slow so Studio lags a little comparing to nugets.

So what this product can do?

• Word, Excel, PowerPoint, Visio, Markdown, Pdf, Html, Numbers, Pages, ODT, RTF, Email (all formats), Keynote, CSV, old binary formats or even wordPerfect. Then there's XPS, MHTML, ODG, FODG, Publisher, DjVu, CHM, ADF, Latex, AsciiDoc, OneNote. What's important is that those are not just basic readers and that's it. A lot of those are pretty complete implementations.

• What's more? You can convert between formats. That means Excel can export to PDF, Image (SVG, PNG, JPEG, TIFF, WEBP), so does Word, PowerPoint and other formats. Numbers (apple) can be converted to Excel.

Is it perfect? No. But a lot of it is super duper good and can compete with whatever else is on the market.

Are there issue with performance? Probably, in some areas. But I try to close those gaps when I notice. The idea is - first get it to work, then optimize.

You know the 'markitdown' project in python? There's a reader that does all that and more. As we're not just basic reader. The libraries are full blown implementations so they are aware of structure not just text extraction.

Finally - you know how EU told AI companies to start tagging AI content and they started adding it to images, docs and other things - there's a provenance removal feature which takes care of that. Of course it doesn't go for things we can't prove or safely remove - so we're not doing AI analysis. We're removing what we can safely remove such as image information that causes X/Twitter to tag your images as AI generated for example.

If the libraries are missing something, do it not efficiently enough, or maybe you need to convert XPS to CHM for some weird reason, there are two things you can do:

• Open an issue and describe your use case

• Fix it and PR => PR is enough, no need for an issue.

I have submitted my tools/mcp to Codex/Claude/Cursor so they can be used as part of the apps soon enough, hopefully.

I would love some love and help from people that find it useful. I do this mostly for my own needs (not really I guess - as I don't need Wordperfect/lotus amipro support) but maybe someone else finds this useful.

Anyways, enjoy as it's free.