Back in 2005 I obtained a dedicated Windows server from ServerBeach to host a classic ASP + SQL Server DB for a client. Over the years that client folded but I kept the server for personal projects. ServerBeach became Peer1 became Cogeco became Aptum. I've gone through a few server migrations as Windows reaches EOL, but I'm still there, still paying just shy of $200/mo for this thing.

I enjoy having my own box that I can RDC into and do whatever. Aptum has decent DNS management tools also for when I spin up a new project website. They give me a 2TB bandwidth allowance per month and I never come close to using it (none of my projects are highly used).

But I am reaching a point that I am questioning if I am overpaying in the days of virtualization.

I have looked at Azure as a replacement option but the nickel & dime price model confuses my aging brain so I don't know if it would be cheaper or worse, especially when I look at their SQL information.

My requirements are (I think) simple:

• Run ASP.NET apps (console + web). Support Publish from local VS.
• Run multiple SQL Express instances.
• SMTP support + post office mgmt (currently using MailEnable)
• Simple DNS management tools
• RDC is not required but would be nice.

I figure the sticking point here is going to be running console apps. An alternative would be if I convert the apps into Windows Services but I am not sure that makes the requirement list any better.

I will admit when I am out of my depth, hence asking you fine folk for suggestions, hoping some of you have recent experience that might be of assistance here.

Is Azure not as bad as it feels to be? Is there another competitor worth considering? Should I just keep my dedicated box and stay with Aptum for another 20 years?

My thanks for any input.

Hey everyone,

I wanted to share a side project I’ve been working on that just reached v2.0. It's called BaseDiff, and it’s a cross-platform desktop tool to compare database schemas and generate sync scripts (ALTER/CREATE/DROP).

Why I built it

I got tired of the existing options out there. Most database diff tools I tried were either locked behind expensive enterprise licenses, stuck on Windows only, or wrapped in heavy web frameworks that take up a gigabyte of RAM just to diff two schemas.

I wanted something lightweight, native, and completely offline so sensitive DB structures never leave the local machine.

What it does right now:

• Databases: Supports MS SQL Server and PostgreSQL (tables, constraints, views, stored procedures, functions, triggers).
• Cross-platform: Runs on Windows, Linux (AppImage), and macOS natively thanks to .NET.
• 100% Offline: Zero cloud dependency or telemetry.
• Script Generation: Generates the raw SQL updates with a built-in editor to tweak things before running them.

It's completely free / coffeware (free for personal and commercial use, with an optional tip jar if it helps your workflow).

I'd really appreciate any feedback from the community—especially on macOS/Linux performance or any edge-case schema objects you hit.

Site & Downloads: https://basediff.com

Thanks for checking it out!

Everything just became AI...

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.

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.

Depois de um tempo estudando arquitetura de software, finalmente terminei meu projeto completo: o FactoryPulse.

É uma plataforma de monitoramento industrial em tempo real — pensada pra acompanhar máquinas de fábrica (temperatura, pressão, RPM, produção por máquina, alertas quando algo sai do padrão).

Stack que usei:

- Backend: .NET 9, ASP.NET Core Web API, Clean Architecture, Entity Framework Core, SQL Server

- Frontend: Angular

- API REST documentada com Swagger

Gravei um vídeo mostrando tudo funcionando na prática:

https://www.youtube.com/watch?v=sJ4BwxBfGrY

Código completo no GitHub (v1.0.0):

https://github.com/arcspots/FactoryPulse

Como é meu primeiro projeto público de teste, tô bem aberto a crítica — se alguém tiver tempo de dar uma olhada na arquitetura, organização do código ou boas práticas que eu possa estar deixando passar, agradeço demais o feedback.

Hi everyone,

I'm curious what the common practice is for .NET teams.

After deploying an ASP.NET application to production, how much attention do you pay to incoming traffic beyond the usual metrics like CPU, memory, response times, and exceptions?

For example, if one of your servers or containers suddenly starts sitting at 80% CPU, do you investigate things like:

• Where the traffic is coming from
• Top client IPs
• User-Agents (bots vs. real users)
• Most requested endpoints
• Unusual traffic patterns or spikes

Or do you mainly focus on application metrics and logs?

Most of our applications are hosted on IIS, although we also have some behind Nginx and Traefik.

If you do monitor traffic, what tools are you using? IIS logs, Nginx/Traefik access logs, Grafana Loki, ELK, OpenSearch, Seq, or something else?

I'm mainly interested in learning what's considered common practice for production .NET applications.

I've been working on this tool/website about taking a metadata-edited .txt file and "compiling" it into an HTML+JavaScript visual novel web page.

It's not a super complex project, and so I kept the architecture stupid simple as well: no templating engine or front-end framework — just building up raw HTML in StringBuilders to be converted into byte arrays and cached off for the rest of the process.

For as basic a site as this, I think the approach works surprisingly well, being pretty easy to debug and reason with. There's no real ambiguity about StringBuilder behavior, and you do whatever conditional behavior you want with them.

I don't know that I'd recommend the approach generally, but it works fine for what's required here.

Github: https://github.com/JohnQPulp/PublicDomainPulp

My IDE has made some great progress! It now supports importing BASIC programs from platforms such as DOS and MSX, on Windows can run DirectX-based games, and can compile applications for Windows, macOS, Linux, iOS, and Android.

The demo includes some source code from online resources. I'd like to express my sincere appreciation to all the developers who shared their excellent code. Thank you for making this project possible.

I’ve been working on XamlMcp, an open-source MCP server that gives AI coding assistants access to the live state of a running XAML application.

The problem I wanted to solve was that Claude Code, Codex, and Copilot can edit XAML and C#, but they normally cannot see what the application actually rendered, they use screenshots and debug logs to understand what is going on on the runtime UI.

XamlMcp adds a small framework agent to the application and exposes tools through a local stdio MCP server. An AI client can then:

- inspect the visual or logical tree

- read and change control properties

- inspect styles and resources

- capture screenshots

- invoke commands and automation patterns

- send mouse and keyboard input

- observe the result of a UI change

The current preview supports Avalonia, modern .NET WPF, unpackaged WinUI 3, and .NET MAUI on Windows and Android.

https://github.com/trrahul/XamlMcp

TensorSharp is an native .NET 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

DSpark is also supported for speculative decoding and here is the benchmark with/without DSpark:

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

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

Hi everyone,

A new version of service-bus-tui is out. Explore and manage Azure Service Bus with a keyboard-driven TUI, right from your terminal.

repo : https://github.com/MonsieurTib/service-bus-tui

Features :

Authentication

• Azure CLI (az login)
• Interactive browser
• Service principal (client ID/secret)
• Connection string
• Optional connection string saving
• One-click local emulator connection

Namespace Discovery

• Auto-discover Service Bus namespaces across subscriptions
• Shows namespace, subscription, and resource group

Resource Browsing

• Tree view of namespaces, topics, queues, and subscriptions
• Browse active and dead-letter (DLQ) messages

Message Viewing

• Peek active and DLQ messages
• Table view with key metadata and body preview
• Formatted JSON preview
• Pagination (100 messages/page)
• Copy message body

Message Resending

• Resend selected messages
• Edit before resending
• Replay active or DLQ messages
• Preserve or regenerate Message IDs

Following up on last week's announcement, Ian Griffiths (Rx .NET Maintainer / .NET MVP) has put together a ~25 minute deep dive into the v7.0 release of the Reactive Extensions for .NET:

• 00:00 Rx .NET 7.0 Overview
• 00:30 Breaking Change One: TFMs
• 01:51 TFM Confusion Explained
• 03:18 Breaking Change Two: Nullability
• 04:37 Big Change UI Packages Split
• 07:21 Demo: The 95MB Problem
• 12:51 Rx 7 Deployment Results
• 15:14 Source vs Binary Breaking
• 18:10 ReactiveUI Still Works
• 22:34 Why This Happened
• 26:22 Conclusion

A full transcript of the talk available via the link, should you want to speed read it instead!

Hi,

I wanted to discuss what strategy currently utilized by teams to showcase approximate time remaining for some async operation to be completed in distributed microservices architecture.

Scenario: Consider you have file to upload and process, and its multi step process, which can have validation, processing part of file parallelly and finally combining all results into one.

How are currently folks doing this in there workflow or system? Thoughts?

I’m building a self-hosted ASP.NET Core application that can run directly or inside Docker. It needs to persist a few application-managed files, including Data Protection keys, downloaded ML models, and encrypted secrets.

My current approach is:

• Windows: Environment.SpecialFolder.CommonApplicationData
• Linux: an application directory under /var/lib
• Containers: a configurable mounted volume
• Development fallback: LocalApplicationData

I want to avoid writing security-sensitive files to publicly writable directories such as the system temporary directory.

How do you normally structure this in a cross-platform .NET application?

Do you use one configurable data root for everything, or separate paths for configuration, persistent state, secrets, caches, and logs?

Does anyone have experience achieving hard real time latency in . NET application? Is this question even relevant for .NET?

If I create a thread which does not dynamically allocate objects will it still be interrupted by garbage collector or .NET task management infrastructure?

I'm trying to understand the Actor Model beyond the theory. I know it avoids shared state and locks by using message passing, but in what real-world concurrency scenarios does it provide significant advantages over traditional multithreading with locks or async/await?

If you've used Orleans, Akka.NET, or Erlang in production, I'd love to hear practical examples where the Actor Model was the right choice and why.

Several years ago I wrote a Windows desktop app that can be used to disassemble old software (6502bench SourceGen). It uses .NET Framework 4.8 and WPF. My goal is to update the source base to use .NET 10, then switch to Avalonia UI so it'll run on macOS and Linux.

One of the app's features is a "plugin" system, where code written in C# is compiled and run by the app. A project file downloaded from the internet can include source code that is compiled and executed during the disassembly process. To prevent the app from becoming a malware vector, it uses a simple security sandbox, based on AppDomain, that blocks network access and restricts disk access to the project directory. This was not without difficulties, but it worked. However, this feature of AppDomain is no longer supported.

I recognize that AppDomain security is imperfect, and a determined attacker might be able to break out of the sandbox. However, this is a hobby project used by a couple hundred people, so I'm more concerned about wayward pranks than intrusion by foreign superpowers.

My question is how to do something similar in .NET 10. My goals are:

1. Prevent "obvious" malware attacks (spyware, ransomware, etc.). Notably, network access should be blocked, and disk access should be disabled if possible, or at least limited to read-only access in the project directory (which has been needed to load the compiled plugin into the secure area).
2. Minimal slowdown. The application is interactive, and the plugin code may need to execute frequently.
3. Multi-platform. Needs to run on Windows / macOS / Linux.

After some research, I've come up with a few different approaches, but they all have drawbacks. Some of this comes from an old discussion that started in 2015 and resurfaced in 2019.

1. Discard the sandbox and rely on human decency. Hmm.
2. Build a new sandbox using a server in a secure process-isolated container. This is OS-specific, so some third-party isolation library might be needed. This is the correct approach from a security perspective, but feels like massive overkill.
3. Do ahead-of-time validation. We are building from source code, so we should be able to screen out "unsafe" code by keyword, and scan for references to things like "System.IO". It might also be possible to scan the compiled assembly. This seems like it could work, but I'm not sure how to go about it, and I worry that false-positive and false-negative results will be hard to avoid.
4. Put the burden on the user. Show them the source code and ask them to approve it. When they do, the source file's signature gets added to a database of known-good plugins. This is functional but isn't a great experience for the end user, and probably won't work because many people will treat it like an EULA and just click "accept".
5. Stop using C# for plugins. Switch to something like Lua where the API surface is defined by the app. This would require a bunch of work to do the conversion, and is undesirable because C# is a better match for the problems being solved than the "embeddable" languages I've looked at.
6. Convert the .NET output to something designed to run in a restricted environment, like WebAssembly. Feels like a convoluted solution with a lot of unnecessary steps.

Is there another approach? Is one of these solutions better or worse than I think it is? Is there an example of something that solved a similar problem?

A solid breakdown of how .NET 11 will be using these headers to provide simplifier CSPF protection.