Projects

Projects Posts

Browse all posts in Projects

Showing 1 - 4 of 4 Posts

BlazorFiddle - Blazor .Net Developer Playground and Code Editor in the Browser

BlazorFiddle is my online Blazor .NET developer playground at blazorfiddle.com — a place where you can edit code, run it, and share a link to a working example. https://blazorfiddle.com/ BlazorFiddle lets you work with more than a single snippet: you can run a project-like setup (multiple components), edit HTML (including your own CSS), and tweak program startup code for service registration—then share it as a runnable repro or demo link. Quick snapshot (as of Jan 3, 2026): Website: https://blazorfiddle.com/ It’s been publicly referenced 17 May 2019 in the Blazor community (e.g., early Reddit introduction; community tooling lists). Reddit It was upgraded over time (the app itself notes a migration “from Blazor 0.7 to .NET 6.0”). Visibility, reach, and ecosystem footprint BlazorFiddle became one of those tools people casually drop into conversations because it solves a simple pain: “show me the problem” (or “show me the idea”)—in a link. A few public, easy-to-verify places where BlazorFiddle shows up (just few examples): ASP.NET Core / Blazor issue tracker: people asked “is there an online live editor for Blazor?” and the answer was essentially “I’m only aware of blazorfiddle.com,” pointing directly to my site. GitHub Official .NET/Blazor bug repros: BlazorFiddle links were used to demonstrate issues in the ASP.NET Core repo. GitHub Stack Overflow answers: BlazorFiddle is frequently used as a live repro/demo in answers across years. Stack Overflow It was used hundreeds of times. Community tooling lists: it’s listed under “Tooling” in awesome-blazor . GitHub Community launch post: I introduced it publicly on Reddit as a Blazor playground and code editor. Reddit Broader dev chatter: it was even referenced in external tool discussions (e.g., StackBlitz issue thread). GitHub And for me personally: at its peak, BlazorFiddle reached thousands of users per day—people experimenting, creating fiddles, and sharing them in issues, chats, and Q&A threads. The story BlazorFiddle was born almost alongside MatBlazor . I was building a component library, constantly needing a way to prove a component works, share a runnable example, and give others a place to tweak parameters and immediately see results. That need shaped the whole product. The first version was intentionally minimal: essentially one component , no real app configuration, no CSS workflow—and the wild part was that it could compile and run the component directly in the browser . It felt unbelievably fast and “alive,” because the feedback loop was instant. Then Blazor changed dramatically as it evolved, and the original “compile in the browser” approach became harder to keep stable. I made the call to move compilation to the backend, even though it meant more complexity and (sometimes) a slower compile loop—because the payoff was huge: BlazorFiddle became more universal, able to handle richer scenarios. That’s when it turned into a real playground: edit multiple files/components (not just one), edit HTML and include custom CSS, edit Program.cs / startup to register services and write additional .NET code, and (crucially) compile in an isolated environment—in a dedicated Docker container—to keep the execution model safer. BlazorFiddle also became deeply connected to MatBlazor: MatBlazor’s own release notes mention the integration, and that integration is exactly what I originally wanted—click an example, open it in a runnable playground, tweak it, learn by doing. Today BlazorFiddle still works—and it still does the job it was built for: a simple, shareable, runnable Blazor sandbox. The app itself reflects the reality of its long lifespan (including the note that it was updated “from Blazor 0.7 to .NET 6.0,” and older saves may need upgrades). But like MatBlazor, it’s not a project I’m actively developing right now. Modern .NET + WASM has improved enough that “client-side compilation” could be revisited in a new way—and that idea is exciting—but I’m choosing not to restart that effort unless the right future context appears. What I do keep is the pride: BlazorFiddle became part of how the Blazor community shared knowledge—bugs, solutions, prototypes, and UI ideas—through a single link.

MatBlazor - Material Design components for Blazor and Razor Components (The End)

MatBlazor is my open-source UI component library that brings Material Design patterns to Blazor / Razor Components —a full component toolkit meant for real apps, not just demos. GitHub Quick snapshot (as of Jan 3, 2026): GitHub: ~2.9k stars , ~377 forks GitHub NuGet: ~2.6M total downloads nuget.org First public releases: Oct 25, 2018 nuget.org Latest package update: Apr 10, 2023 nuget.org GitHub “Used by”: ~2.1k repositories (dependency indicator) GitHub Visibility, reach, and real-world usage MatBlazor started early—when the Blazor ecosystem still lacked a “default” set of solid UI components—and it quickly became one of the most visible open-source component libraries in that space. Even I openly wrote at the time that it had grown into “one of the most popular libraries for Blazor,” while also being hard to carry alone. That visibility had a very real impact on me personally: I was mentioned in videos, invited into community conversations and conference contexts, approached by companies interested in adopting the library, and even contacted by a major publisher (won’t name them) with a proposal to write a Blazor book—because MatBlazor positioned me as someone who deeply understood the platform. Here are a few public examples of MatBlazor being used / referenced: BlazorBoilerplate — “real world starter app” built with MatBlazor (auth/authz, admin-style template). https://github.com/enkodellc/blazorboilerplate ABP Framework — community article showing how to integrate MatBlazor into ABP’s Blazor UI. abp.io MatBlazorTemplate — default Blazor template converted from Bootstrap to Material using MatBlazor. GitHub BlazorFiddle — shared publicly as being written with MatBlazor components. Reddit Awesome Blazor Browser — MatBlazor listed as a notable library in the ecosystem. And one more angle that I actually love: the MatBlazor site publicly listed sponsors/backers at one point—including individuals and also organizations—showing that it helped real teams enough that they supported it (e.g., Apply Solutions GmbH, SmartView Systems, Gate575 Kft, Beeman and Sons, Inc.). The story (2018 → peak years → burnout, the classic OSS curve) I started MatBlazor in October 2018 , long before Blazor felt mainstream. My goal wasn’t “a few controls”—it was coverage: a component set capable of supporting real business apps. For roughly the next year, I worked intensely and shipped fast. The library grew quickly, the community grew around it, and MatBlazor became a recognizable name in Blazor UI. It also became a serious responsibility. And the most important detail (that shaped everything): I was essentially the solo maintainer . The architecture, the components, the releases, the issue triage, the support, the docs—most of it ran through one person. I even wrote publicly that it was hard “to be alone” handling everything. Donations and sponsors did exist—and I’m genuinely thankful for everyone who supported the project—but the financial side never became a sustainable foundation compared to the amount of work and responsibility. And because Blazor wasn’t part of my day job, I couldn’t “reinvest” the effort into my work life in a way that kept the motivation steady. Eventually, I hit what many open-source maintainers hit: burnout. Later on, as MatBlazor slowed down, MudBlazor grew into the new default choice for many Blazor teams—largely because it had a strong, active contributor base and consistent momentum. I have a lot of respect for that team and what they’ve achieved, and it’s great for the ecosystem that the “Material for Blazor” space kept moving forward. And yes—when I looked through their codebase, I recognized several ideas and patterns that felt familiar from MatBlazor, which I take as a quiet compliment rather than a point of conflict. Where MatBlazor stands today (and my thank you) Since early 2021, MatBlazor hasn’t been actively developed, and I’m not planning to return to active maintenance in the near future—unless the right future context appears (work needs, a new motivation, or a strong practical reason to invest again). But I’m proud of what MatBlazor achieved: it’s a real, proven project with real adoption, and it remains one of the most important chapters in my engineering journey. And I want to end this the right way: with gratitude. Special thanks to the people who supported and contributed early and meaningfully, including enkodellc , CrystalAlison, Petajobby, CtrlAltD —and to every contributor, sponsor, donor, tester, and user who helped MatBlazor become what it became.

The World of Bots and Genetic Algorithms

About half a year ago, I stumbled upon a video where someone created artificial intelligence. This video completely changed my understanding of what can be achieved with AI. Recently, I fell ill and decided to create something similar. So, I made little blue bots that will survive on their own in the world. The bots have a brain—a micro-program that serves as the bot's genome, which will be created and evolve on its own. The brain consists of 64 memory cells (numbers). Each number is a command. Commands: move, turn, grab food or convert poison into food, check what’s in the neighboring cell, unconditional jump, added long-range vision (to check a cell farther than the neighboring ones). In the beginning, all cells are filled with random numbers, then the bots are placed in the world, where they can perform one movement command and up to 10 other commands per turn. If a bot steps on food, it gains 10 health points; if it steps on poison, it dies. Each turn, the bot loses 1 health point. When the health drops to 0, the bot dies. After each simulation of the world’s life, the new generation is composed of only the best bots from the previous simulation, and mutations are added (random changes to a few memory cells). As a result, the bots start evolving, and with each generation, they become smarter. If you let a few generations (a few thousand) pass, the bots become quite capable of surviving. For fast simulation of many generations, press the "Fast by Generations" button. You can then switch back to "Slow by Step." Overall, the idea was inspired by the video and developed a bit further. The code is written in TypeScript/JS and posted on GitHub. Demo link: SamProfAI Demo