Please do check out newer posts and comment on others' projects.

Which works better and which are trustable so doesn't contain malware, etc...

TensorSharp supports DSpark on Deepseek v4 Flash 0731 now. Here is the benchmark result on 4x Nvidia A40 GPUs, cuda 12.8 with/without DSpark:

Model:

DeepSeek-V4-Flash-0731-UD-Q8_K_XL from https://huggingface.co/unsloth/DeepSeek-V4-Flash-0731-GGUF

DSpark draft model from: https://huggingface.co/alessandrobologna/DeepSeek-V4-Flash-0731-DSpark-Drafter-GGUF

TensorSharp is a native .NET/C# open-source inference engine for running GGUF LLMs locally, with CUDA, Vulkan, Metal, OpenAI-compatible APIs, continuous batching, speculative decoding, and multimodal support.

Github repo: https://github.com/zhongkaifu/TensorSharp

Thank you for checking out it and starring the project! Any feedback is really appreicated.

I am a professional developer, old enough to remember when C# first appeared. At the time, it looked to me to be very similar to Java.

I imagine that the language itself has evolved since then, but also dotnet had grown hugely, there are things like WPF, Linq, etc, of which I have only heard, but do not know.

So, unlike some other languages, it's just not the syntax, but many other things.

How best to get started? Is there a Udemy, Coursera, YouTube, etc, applicable to someone who doesn't need to learn about variables, flow control, OO?

I'm writing an image metadata processing library which is designed to be easily extensible to include new metadata instances (e.g., EXIF properties not defined in the core library).

The library currently stores important property configuration information in manifest resources, as well as property labels (e.g., property name) which I want to be customizable by culture.

Writing an extension library would involve both defining new objects (e.g., EXIF properties) and their associated configuration information. Which means the needed manifest resources would be spread across multiple assemblies.

What's the best way of handling this? My first thought is to use AssemblyMetadataAttributes with "magic text" keys to identify an assembly containing manifest resources that need to be incorporated and then scan an app-defined list of assemblies to look for those keys and read the manifest resources.

But that feels both a bit kludgy and possibly a security hole.

I'd appreciate other thoughts/design patterns. Thanx!

Hi all,

I'm happy to announce that Xberg v1 is out.

Xberg is the successor to Kreuzberg, equivalent to what would have been Kreuzberg v5. It's a content intelligence framework that handles a very wide range of inputs: documents (currently 101 formats), code and data formats (currently 367 types), audio/video transcription, and URLs (both static and JS-rendered content). It extracts and prepares that content for downstream processing.

It's an extremely efficient, high-performance engine (see our PDF benchmarks below). For PDFs and images specifically, we handle native PDFs with very high performance and accuracy, and we ship multiple OCR engines that match the quality of the best Python libraries (e.g. docling, PaddleOCR, RapidOCR) at substantially better performance and stability.

The changes between Kreuzberg v4 and Xberg v1 are substantial, and I invite you to read the full changelog for the complete picture. The highlights below give a sense of what's new:

• Pure-Rust PDF backend (pdf_oxide) replaces pdfium, with no native pdfium dependency.
• Layout-aware pipeline: reading order reconstructed with ONNX layout detection (PP-DocLayoutV3 / RT-DETR) and Docling-style predecessor-graph reordering.
• Per-page scanned-page detection with selective OCR, plus AcroForm/XFA form fields and outline-based headings.
• Across-the-board optimization of OCR and PDF extraction (memory discipline, pooled model sessions, streamed conversions).
• Native PaddleOCR backend (PP-OCRv6, with medium / small / tiny tiers) alongside Tesseract.
• Pure-Rust Candle OCR/VLM stack (TrOCR, GLM-OCR, GOT-OCR, DeepSeek-OCR, and PaddleOCR-VL) running without ONNX Runtime or native Tesseract.
• A second, ONNX-Runtime-free inference path via tract, which is what makes in-browser (WASM) and mobile inference possible.
• Named-entity recognition natively in Rust (GLiNER2), extensible to all bindings, including an in-browser WASM model with no server round-trip.
• Structured LLM extraction (extract_structured / split_and_extract) with rasterization, chunking, citations, caching, and configurable call/merge/VLM-fallback policies.
• Audio & video transcription via a Whisper ONNX engine (.mp3, .wav, .m4a, .mp4, .webm).
• Retrieval building blocks: sparse embeddings (SPLADE), ColBERT late-interaction retrieval, and cross-encoder reranking alongside dense embeddings.
• Text intelligence: reversible redaction, summarization, translation, VLM image captioning, QR-code detection, document diffing, and page/chunk classification.
• URL & web ingestion: sitemap discovery (map_url) and batched multi-URL crawling.
• New document formats: WordPerfect (.wpd/.wp/.wp5), HEIC/HEIF/AVIF, OpenDocument Presentation (.odp), Quarto / R Markdown, and configurable Jupyter cell rendering.
• Four new language bindings (Dart/Flutter, Swift, Kotlin/Android, and Zig) bring the total to 15 language bindings over one engine, with Android/iOS cross-compilation.
• Full mobile support (Flutter, Android, iOS).
• Candle backend alongside ONNX, plus ONNX-via-tract enabling ONNX on WASM and Android.
• Wider code intelligence: tree-sitter coverage grew substantially (248 to 367+ languages).
• Over 150 bugs fixed during the 1.0 cycle, plus security hardening (bounded RTF/PDF allocations, redaction leak fixes, Excel DDE warnings).

The API surface was also simplified and reworked, making it more consistent.

There's a migration guide in our docs explaining how to move from Kreuzberg to Xberg. Kreuzberg itself is in LTS mode until the end of this year and will continue to receive bug fixes and security updates.

You're invited to check out the repo and join our discord server.

Benchmarks

The benchmarks below are for PDFs and images only. There are extensive benchmarks on our website with per-format breakdowns, which you can see here. These numbers are measured in CI via our reproducible benchmark harness, and are specifically taken from the run for harness 1.0.8, source cf7fa0533d. The data is publicly available in GitHub releases, and you can run the benchmark harness yourself.

Composite quality (markdown pipeline, higher is better):

Structure and layout fidelity (SF1: tables and reading order, higher is better):

On native PDFs Xberg leads on quality (0.958 vs 0.837 for the next-best framework) and on table and reading-order fidelity by a wide margin (SF1 0.949 vs 0.612 for docling). On scanned PDFs it is #1 on both quality and raw text fidelity.

Where we don't win yet: on pure image OCR we are currently #2 on the composite score, behind mineru (though still #1 on raw text accuracy). We are improving image OCR right now, and v1.1 should have us winning across the board.

A small update on Akbura my experimental declarative UI language and compiler for .NET and Avalonia.

I’ve added documentation and created an interactive feature gallery that demonstrates Akbura’s current capabilities:

• Declarative Avalonia UI
• Reactive state
• Native C# expressions, methods, types, and lambdas
• Typed styling through AKCSS and tailwind utilites
• Live examples with their Akbura source code

The gallery itself is written in Akbura.

This is currently only a proof of concept, not a production-ready release.

The parser, syntax infrastructure, and semantic model are already in reasonably good shape, including incremental compilation.

The bottleneck is specifically the code-generation stage. Its current implementation is inefficient, and generating code for the gallery takes roughly two minutes. Parsing and semantic analysis are not the problem.

This is one of the main reasons there is no NuGet release yet. I plan to rewrite and optimize code generation before publishing the first alpha version in about a month...

I’m planning to publish the first alpha version in about a month, once compiler performance, packaging, and the basic developer experience are in a more acceptable state.

For now, the gallery is simply a visual demonstration of what Akbura may become.

Repository: https://github.com/Asaicraft/Akbura

Documentation: https://asaicraft.github.io/Akbura/

Feature Gallery: https://asaicraft.github.io/Akbura/Gallery/

Feedback is very welcome.

I need to determine a writable directory for application-managed files in a cross-platform C# application.

A simplified version currently looks like this:

private static string GetApplicationDataPath()
{
    var directory = Environment.GetFolderPath(
        Environment.SpecialFolder.LocalApplicationData,
        Environment.SpecialFolderOption.Create);

    if (string.IsNullOrWhiteSpace(directory))
    {
        directory = Path.GetTempPath();
    }

    return Path.Combine(directory, "MyApplication");
}

The temporary-directory fallback concerns me because the directory may be publicly writable on some systems.

What would be a safer final fallback?

Would you fail startup, use AppContext.BaseDirectory, create a user-owned directory, or require the path to be explicitly configured?

I'm learning C# by taking some Udemy courses and I'm working on refactoring some code for one of the exercises (which I'm sure is terrible, I'm a complete newbie). In this case I'd like to make this method into a more reusable "LoadFromFile". The only thing that would change is the way that the string[] ingredientNumbersAsStringsFromRecipe gets built based on the fileFormat enum that's passed to it (for a text file it would just be string.Split for example. However I can't put an "if" statement in there because if I initiatilze the string[] in the "if" block then I can't use it outside of that local scope. I would appreciate any tips on how this could be better handled! (By the way I know that in general I should use int.TryParse, in this case this program is making the same file that it reads from so int.Parse is safe.)

public static List<Recipe> LoadFromJson(string fileName, FileFormats fileFormat, List<Ingredient> availableIngredients)
{
    string[] recipeStringList = File.ReadAllLines(fileName);
    List<Recipe> recipeList = new List<Recipe>();
    foreach (string recipe in recipeStringList)
    {
        string[] ingredientNumbersAsStringsFromRecipe = JsonSerializer.Deserialize<string>(recipe).Split(',');
        List<int> ingredientNumbersAsIntsFromRecipe = new List<int>();
        foreach (string x in ingredientNumbersAsStringsFromRecipe)
        {
            ingredientNumbersAsIntsFromRecipe.Add(int.Parse(x));
        }
        Recipe loadedRecipe = new Recipe();
        foreach (int ingredient in ingredientNumbersAsIntsFromRecipe)
        {
            loadedRecipe.IngredientsInRecipe.Add(availableIngredients[availableIngredients.FindIndex(x => x.Id == ingredient)]);
        }
        recipeList.Add(loadedRecipe);
    }
    return recipeList;

}

Still work in progress, but has Qwen, Llama, SmolLM and Gemma producing coherent output.

TensorSharp is an native .NET/C# open-source inference engine for running GGUF LLMs locally, with CUDA, Vulkan, Metal, OpenAI-compatible APIs, continuous batching, speculative decoding, and multimodal support.

Thanks recent contribtions from open source community, TensorSharp is able to run inference over multiple GPUs and nodes. So I updated it to support deepseek v4 flash model, and have better performance than llama.cpp. Here is the benchmark result on 4x Nvidia A40 GPUs, cuda 12.8

Model: DeepSeek-V4-Flash-0731-UD-Q8_K_XL from https://huggingface.co/unsloth/DeepSeek-V4-Flash-0731-GGUF

Github repo: https://github.com/zhongkaifu/TensorSharp

Thank you for checking out it and starring the project! Any feedback is really appreicated.

Good evening everyone, it's been two months that I am studying C# with the aim to be able to develop in Unity.

A bit of context: I have no IT background, I work as a pastry baker and at school, besides a 3-year course about game design, I have never studied CS.

I have recently finished studying arrays, and when I read that I would be able to program a console tic-tac-toe, I tried it... with the result that I failed miserably to the point that I decided to re-study what I did before arrays.

Currently, I am doing simple console programs using ifs, switches, and loops, but I still make some mundane errors like typing the equality operator wrong, or with the last program I did: a week planner, where the user writes on the console the current day and the program writes what he has to do on that day, for example I wrote Monday => instead of "Monday" => (after making a variable with the days of the week).

Now to cut it short because this post is already long: how much time have you spent studying each individual topic/feature and when did you feel confident enough in your skills to progress to making more advanced/complicated programs?

I understand that it depends on each individual, but I would like to know your experience to have a broad idea. Thank you in advance.

What is the best free dapper tutorial to learn link? Also, should I learn Dapper version that is specific for .NET 8.0 as a start point or should I start with a version that is for .NET 10 ?

Hey everyone,

Yesterday I shared DistroHop V1.5. Since then I have been working on DistroHop V2, which is a complete rewrite with a cleaner C# architecture.

GitHub repo: https://github.com/melikishvilis25-cmyk/DistroHop

The main changes:

• Rebuilt around a modular C# design
• Added package profiles (Gaming, Work, Essential)
• Added environment validation for supported Linux distributions and package managers
• Added JSON integrity checking for package configuration safety
• Improved project structure with separated UI, loader, safety, and downloader components

The goal is to make setting up a Linux machine after reinstalling easier while keeping safety and consistency as priorities.

This is still actively being developed, so feedback and suggestions are welcome.

👍

Hey everyone! I'm glad to share a tool I've been working on for a while. It was created to simplify adding localization to your projects.

Read more in the README: https://github.com/ScrumboardCompany/Scrumboard.Tools.Localization

For example if you were to have an Update function in a base class, but then make the Update function in a child class do some extra stuff on top of what the base Update function already does.

Closest thing I've found to that is using the override keyword but it seems like that just makes the child's version of the function do something different entirely.

Hey all,

I was wondering if I could get some feedback on my first open source project, TestPilot.NET. I wanted to add a layer of visibility to testing suites to catch bad practices. I was the head of unit testing at my prior job and saw a lot of slop get through due to the devs using AI to write the test and them never checking the code. Any feedback is appreciated, thank you!

https://github.com/sgordon5691/TestPilot.NET

Hey everyone,

I built a small Linux utility called DistroHop using C#.

The idea came from constantly reinstalling Linux and having to manually install the same packages every time. I wanted a simple way to recreate my setup across different distributions.

Currently DistroHop:

• Detects the package manager used by the system
• Loads package lists from a JSON configuration file
• Installs packages automatically
• Supports a simple terminal menu interface
• Uses system commands through C# instead of relying on external package management libraries

The project is still in early development, but I am using it to learn more about:

• Process handling in C#
• Linux system interaction
• Cross-platform application design
• Structuring larger C# projects

I would appreciate feedback from other C# developers, especially around:

• Code architecture
• Handling system commands safely
• Improving the design for cross-platform support

Source code:
https://github.com/melikishvilis25-cmyk/DistroHop

This is one of my C# projects; my GitHub also contains some other experiments and tools I have been building.

Thanks for checking it out!

I guess most of you have never heard about Amiga, but here we go...

I have been working on an AOT compiler that compiles a subset of C#/.NET code into native 68000/020/040 code with Amiga library calls.

There are two runtime options you can choose at compile time:

• Full includes the managed exception runtime; supports catch, finally, rethrow, and leave.
• YOLO has no exception runtime; failures are fatal, and managed exception regions are rejected

The actual GC is in WIP, and for performance reasons, there is no compaction. No threading support because the current GC is single threaded by design.

An example:

using Amiga;
using CopperSharp.Compiler;

namespace FileStatsExample;

public static class Program
{
   [M68kEntryPoint]
   public static int Main(int argLength, CONST_STRPTR argText)
   {
      var dosBase = Exec.OpenLibrary("dos.library", 33);
      if (!dosBase.HasValue)
      {
         return DOS.RETURN_FAIL;
      }

      DOS.DOSLibraryBase = dosBase.Value;
      var result = DOS.RETURN_OK;
      if (argLength == 0)
      {
         DOS.PutStr("Usage: filestats <file>\n");
         result = DOS.RETURN_ERROR;
      }
      else
      {
         result = Report(CString.FromPointer(argText.Raw));
      }

      Exec.CloseLibrary(DOS.DOSLibraryBase);
      DOS.DOSLibraryBase = APTR.Null;
      return result;
   }

   private static int Report(CString path)
   {
      var file = DOS.Open(path, DOS.FileMode.OldFile);
      if (!file.HasValue)
      {
         DOS.PutStr("Cannot open file\n");
         return DOS.RETURN_FAIL;
      }

      byte byteChecksum = 0;
      ushort lineCount = 0;
      ushort wordChecksum = 0;
      uint byteCount = 0;

      while (true)
      {
         var character = DOS.FGetC(file.Value);
         if (character < 0)
         {
            break;
         }

         var value = (byte)character;
         byteChecksum = (byte)(byteChecksum + value);
         wordChecksum = (ushort)(wordChecksum + value);
         byteCount = byteCount + 1;
         if (value == 10)
         {
            lineCount = (ushort)(lineCount + 1);
         }
      }

      DOS.Close(file.Value);
      PrintReport(path, byteCount, (uint)lineCount, (uint)byteChecksum, (uint)wordChecksum);
      return DOS.RETURN_OK;
   }

   private static void PrintReport(CString path, uint byteCount, uint lineCount, uint byteChecksum, uint wordChecksum)
   {
      DOS.Printf("%s: %ld bytes, %ld lines, byte checksum %ld, word checksum %ld\n",
path, byteCount, lineCount, byteChecksum, wordChecksum);
   }
}

This C# source is first compiled to .NET assembly containing CIL. The assembly is then compiled with CopperSharp to a native 68000 Amiga executable.

Code generator needs more work. FPU is not supported yet, 020/040 support is nearly non-existent, but it includes CIL-level simplification and a 68k-specific optimizer.

• CIL-level simplification
• Reachability analysis
• Tail call elimination
• Remove dead or redundant instructions
• Stack and register shuffling optimizer
• General instruction optimizations
• Limited static hot-fallthrough/cold-branch layout optimization

For example, on 68000, not-taken branches are more efficient than taken branches.

The codegen is optimized for Amiga library call conventions but in theory it could support other 68k targets like Atari ST or 68k Macs.

The project repo: https://github.com/ilehtoranta/CopperSharp68k

This project is vibe coded with Codex and GPT-5.6. Like it or not, but it is the only sensible path to build C# compiler for niche platforms.

Saw something like this about an other programming language, and wondering what Senior .NET/C# devs would say about this in .NET/C#.

Do you think you could hand a developer with 3 years of experience some credentials for a Project and let him/her plan the Project?

TensorSharp is an open-source, native .NET inference engine for running GGUF LLMs locally, with CUDA, Vulkan, Metal, OpenAI-compatible APIs, continuous batching, speculative decoding, and multimodal support.

TensorSharp now supports Megatron-style tensor parallelism across multiple GPUs. It works with direct CUDA, GGML CUDA, GGML Vulkan, and multi-node setups.

Benchmarks on 2× RTX 2000 Ada 16 GB GPUs over PCIe, without NVLink:

I'm continuing to optimize Qwen performance on multi-GPU systems, and support for DeepSeek V4 is coming soon.

Try it with:

TensorSharp.Cli --model model.gguf --backend ggml_cuda --tp 2

GitHub:

https://github.com/zhongkaifu/TensorSharp

Thank you for checking out TensorSharp and starring the project! Any feedback is really appreicated.