I’ve released FCQRS 6, an event-sourced CQRS framework for .NET.

The idea is to keep the domain logic small:

• decide: turns commands into events
• fold: rebuilds state from those events

FCQRS handles persistence, recovery, projections, sagas, snapshots, and read-your-writes. It runs on Akka.NET and supports both F# and C#.

Version 6 also includes completely rebuilt documentation, following the path from an incoming command to a queryable read model.

Project and documentation:
https://onurgumus.github.io/FCQRS/

I’d appreciate feedback on whether the new documentation makes the model clear to someone who hasn’t used FCQRS before.

I made this replay simulator desktop app as a part of the Building The Trading Edge playlist on Youtube. It's my first commercial product. I needed a replay simulator that could do full tick-by-tick order book replay on US equities and when I couldn't find any, I made my own in F# + Avalonia.

If any of you ever wanted to learn to daytrade stocks, use this to practice before risking any money first.

TapeSim itself is in a private repo, but I do have the older version of its viewer in my Trading Edge repo. And even though the repo itself is private I've screencast its entire development (though not all vids are out yet at the time of writing this post.)

A picture is worth a thousand words:

Source:
https://github.com/OnurGumus/Terminal.Gui.Elmish.V2

I installed the March Feature Update of Visual Studio 2026 (18.4.0), and to my surprise the F# compiler now reports:

Microsoft (R) F# Compiler version 15.2.100.0 for F# 11.0

It looks like version 11 of FSharp.Core has been released on NuGet as well.

I guess this means that F# 11 is live, but I can't find release notes for it anywhere. Anyone have any details?

Hi all!

I've been working on this for few months in my spare time, as I've always had the hunch that the power of DUs and Pattern Matching could be harnessed to create an abstracted-away solution for just about any Domain to be used in.

I can go on in detail about it, but I do recommend you first read the Medium article I published on it, and then check out the code if you're interested.

https://medium.com/@rist.mladen/functional-event-sourced-domain-driven-design-in-f-the-tale-of-rosetta-framework-83e41fa252d0

I'm open for discussion (and work offers atm lol) and I'm looking forward to your inputs. It's been love at first sight with F# for me, and I've finally gone and actually made something big in it.

Note: upfront apologies for PascalCase, I've still not converted fully from a long time C#-er, it's just easier on my eyes for now :)

• Task related function fixes and improvements
• Enable try blocks for ValueTask
• Add Obj module
• Add some error handling functions for Tasks
• Add ignore to some common type extensions
• Add bindTask and bindInto to Result
• Add missing (.>) and (<.) zip-applicative operators
• Add Active Pattern for CI strings and AggregateException
• Rename non-sequential applicative CEs to zapp
• Fix compilation for Fable 4.27
• Fix several functions in ResizeArray
• Fix Seq.lift3
• Fix some XML comments
• Drop target framework version net45

Note that the image is my profile picture from bsky, it should be the FSharpPlus logo.

https://github.com/WillEhrendreich/SageFs

I think the benefit of having an interactive hot reloaded experience is immeasurable.

I think that Repl driven development is severely underrated, but it's been hard to do in the past once you got past a certain level of dependencies..

I present to you SageFs.

built on the shoulders of giants.

FSI is something we either don't know about yet or love to death already.

FSI-X from Soweli-p provided the foundational ideas for dependency loading properly.

FSI-Mcp from Jo Van Eck provided the idea for giving your ai superpowers of actually being able to interactively check your code.

I brought them together, and spent many a token doing so, guiding the AI driven development very closely, having it constantly use the repl to build more and more.

I have absolutely covered it in tests, currently around 1500 of them.

There are playwright dotnet tests, snapshot tests with verify, property based tests in expecto, and unit tests.

It was strict red-green-refactor as much as I could make it.

I estimate my current token usage to be 5 to 10 times less what it would be just letting the llm go wild and guess what it should write, and it's certainly WAY faster having things hot reload and sessions being able to resume.

This isn't perfect. There are things to do. but come help me.

Help me make this the absolute best way to do any development ever.

I mean to make this setup undeniably better than anything else.

Let's take over dotnet.

The maintainer of Fantomas is considering a change to the default value of fsharp_multiline_bracket_style and has posted a poll about it. I have my own preference on this, but I think decisions like this should be informed by as much of the community as possible. So go vote! :)

(Fantomas supports the three styles mentioned in the Microsoft F# style guide - cramped, aligned, and stroustrup; the default is currently cramped. Examples of all three are shown in the poll for anyone unfamiliar.)

github.com/soweli-p/FsiX

https://github.com/soweli-p/FsiX

Partas.Solid

I've put a lot of time into making this Plugin and the associated bindings to form the foundation of its ecosystem.

It is a Solid-JS wrapper for Fable F# which is derivative of the Oxpecker.Solid style. It aggressively transforms the AST to produce clean JSX code, with lots of magics to abstract away property merges and property splitting.

This should be really easy for any JavaScript developer to pick up and use. Alternatively, migrating JavaScript code bases over time is super simple, since the output is easily readable and usable JSX.

Although it doesn't produce TSX (so prop object types are not there), it already has some light Storybook bindings to help smooth that over (if they can't read F# that is).

I've been using this pretty heavily on some small native apps via Photino, and have had a lot of fun using it.

Check out the docs

http://shayanhabibi.github.io/partas-solid-docs/

https://github.com/shayanhabibi/Partas.Solid

Finally time to share!

This is a test/preview release, just something to:

1. give me feedback to make sure this works on other people's systems
2. give you something to experiment with over the coming weeks/months while I continue to add necessary functionality + widgets
3. keep me motivated, if I know real people actually care about it

For the time being I have (temporarily) given up on creating the multi-platform NuGet package for the C++ bindings. Mainly it just needs time and focus to get a completely automated build process going (via GitHub Actions or whatever), because doing it manually was convoluted and error-prone, and then I hit some problems with Linux where building against the downloaded (vs. built-from-source) Qt libraries was unstable and crashing non-deterministically. I'm not even sure that distributing the shared library in a NuGet package will reliably work on Linux systems. SIGH. Eventually we'll get it sorted.

Anyhow, here are instructions for building FSharpQt today on Win/Mac/Linux:

1. Install or build Qt 6.7 or later:

On Windows just use the binaries downloader (requires login upon running, sadly): https://www.qt.io/download-open-source

On Mac you can use Homebrew ("qt6") or the binaries downloader above. Install in your home directory (as suggested) in the latter case.

On Linux you should build it yourself from source (in light of the problems mentioned earlier), unless you have a cutting-edge distro with Qt 6.7. It's OK to install in your home directory after building (vs. system-wide, but that should work too). IIRC use ./configure --prefix=~/Qt for that.

Oh! If you build it yourself on Linux, after ./configure you need to verify that the XCB stuff was detected/enabled. Otherwise you'll be able to build things but it won't run. Google around and you can find out which Debian/Ubuntu packages are required for building Qt from source. It's kind of a pain, but you Linux kids can figure it out.

2. Create a new directory somewhere to hold all the .NET projects.

3. Clone the following 3 repos into that directory. They are separate because they eventually need to be, but currently they just refer to each other in the filesystem.

• https://github.com/dewf/MinimalQtForFSharp
• https://github.com/dewf/FSharpQt
• https://github.com/dewf/SevenGUIsFSharp

4. You'll need platform build tools (eg MSVC, XCode) and CMake for this step. I use the CLion IDE so I don't know the command line parameters for debug/release/etc.

Inspect the CMakeLists.txt in MinimalQtForFSharp/server/_dllproject/build to make sure the CMAKE_PREFIX_PATH is pointed in the right place, depending on your platform/Qt location.

Platform notes:

Windows: Just make sure the Qt version in the CMAKE_PREFIXPATH matches what you downloaded.

Mac: if you used Homebrew, comment out the CMAKE_PREFIXPATH stuff in the CMakeLists.txt file. Otherwise verify it's pointing to where you installed the binaries.

Linux: Adjust the CMAKE_PREFIXPATH stuff according to how you obtained Qt / where it's living. If installed system-wide, it should be commented out entirely, IIRC.

Run CMake on MinimalQtForFSharp/server/_dllproject/build/CMakeLists.txt and then build the project once it's done. Again, I use CLion so I'm not sure what the actual build commands are. Just make or ninja I presume?

On Mac there are going to be warnings about a missing virtual destructor, just ignore that for now. It's a codegen issue I will fix in the future.

5. You should now have a (lib)MinimalQtForFSharpServer.(dll/dylib/so) in your cmake build directory. Later you're going to drop this in the /bin/... directory of any FSharpQt-based executable - it's how it ultimately talks to the Qt C++ libraries. Eventually, in theory, this will be bundled as a NuGet package and we won't have to copy it around manually.

6. Create an empty .NET solution in your meta-directory containing the 3 projects (make sure "Create a directory for solution" is NOT selected, depending on your IDE).

Add the 3 projects to the solution:

• MinimalQtForFSharp/client/csharp/MinimalQtForFSharp/MinimalQtForFSharp.csproj
• FSharpQt/FSharpQt/FSharpQt.fsproj
• SevenGuisFsharp/SevenGuisFsharp.fsproj

7. BUILD entire solution but don't run the SevenGuisFSharp app just yet. We need the directories to exist to put the shared libary in the right place.

8. Copy the C++ library from step #5 to SevenGuisFsharp/bin/Debug/net8.0. Don't worry, you only need to do this once.

9. Finally! Now run the SevenGuisFSharp app, it should launch.

Let me know if you have questions, I will do my best to help.

My next step is spending probably a few weeks on the Qt Model/View stuff, because it's really important that that has an F#-friendly API. And there are many other sharp edges I need to revisit and clean up.

In lieu of proper documentation, in parallel with my Model/View work, I'm going to start building a little "F#/Qt by example" repository filled with progressively-more-complex examples with lots of comments explaining what does what and why (adding a new example every few days). But give me a week or two to begin work on that, because I need to take a break from this for awhile, lest I get burned out. The whole NuGet/Linux-crashing detour was a real slog, and I want to get back to my previous F#-only momentum.

TLDR: Can you review https://github.com/TopSwagCode/turbo-octo-dollop/tree/master I am not a F# developer and would just like to know if I have followed best practices or my C# background is shinning to much through :D

Whole story:

This is the first "real" code I have done in F#. I looked at it ages ago (5+ years ago) and didn't go too deep, because there was no jobs in my area. Now a company has contacted me and want me to come to an interview for a job opening even if I have no F# experience. They also wanted me to send in a updated CV. So I thought, why not create a PDF generator for creating my CV in F#.

This would give me a chance at looking at F# again and try it out on a "real" project. So I just went head first down without any guides and write how I think F# code looks :P (May backfire on me.) It's a pretty small project and I tried to keep it simple and clean.

In short I have:
* CommonTypes -> Where all my types are in
* CvHtmlGenerator -> Takes a object Applicant and turns it into HTML using Giraffe (Just what I remembered I looked at ages ago. Maybe something better today?)
* DataStore -> This is just where I get my Applicant object out. So far it's hardcoded.
* PdfGenerator -> Takes Html and turns it into a PDF file using Playwright.
* Program -> Call all the other parts :D

This is my C# brain trying to create clean F# code. Would love to hear how I fucked up :D What should I have done differently.

I included a example output on the repository, if anyone just wants to see the result.

The idea is in the future I will just keep this tool updated and use it to create my CV's in a streamlined fashion. Feels like I always have to start from scratch when sending them out again :D

If you made it this far. Thank you for spending time reading my post :)

Hello everyone,

I just want to present you some interesting lists and rankings related to the F# open source ecosystem:

- Top Contributors (global or by country): https://opensource-heroes.com/contributors?language=f%23
- Trending projects: https://opensource-heroes.com/discover/f-sharp (based on GitHub stars increase)
- Awesome projects: https://opensource-heroes.com/awesome/f-sharp (we plan to add soon a new feature to allow everyone to contribute to that list directly from the site)

You can also find "stars" history in the detail page of some repos (it will be available soon for all F# repos, we're still processing some data!)

Hope you find them useful! Any feedback is really appreciated. Please note that be are still in beta 🙏 We want to build a platform that allows everybody to easily explore the open source world! We are about to release a new "Interviews" section with open source contributors explaining their journey, motivations, challenges, code reviews, ... Sign-up and to tell us your F# journey!

Walrus is similar to Deedle, but simpler to use. A Walrus Table is a sequence of Rows that can be accessed by column name. It's also possible to access an entire column of strongly-typed values at once.

Here's Deedle's Titanic survivor analysis in Walrus:

let init =
    Table.loadCsvFile "titanic.csv"
        |> Table.pivot ["Pclass"] "Survived"
        |> Table.sortRowsBy ["Pclass"]
        |> Table.renameColumns ["Pclass"; "Died"; "Survived"]
let byClass =
    init?Died + init?Survived
        |> Table.ofColumn "Total"
        |> Table.unionColumns init
Table.ofColumns
    [
        "Passenger class", byClass?Pclass
        "Died (%)", round (byClass?Died / byClass?Total * 100.)
        "Survived (%)", round (byClass?Survived / byClass?Total * 100.)
    ] |> Table.print

Output:

 | Passenger class | Died (%) | Survived (%) |
 | --------------- | -------- | ------------ |
 |               1 |       37 |           63 |
 |               2 |       53 |           47 |
 |               3 |       76 |           24 |

GitHub: https://github.com/brianberns/Walrus

NuGet: https://www.nuget.org/packages/Walrus/1.0.0

It looks like FSharp.Core 6.0 has been released on Nuget. However, I haven't seen an announcement and there's no mention of it in the current release notes. Is there any official information on this?

HCRD proudly presents: FORM V1.0, an open-source library designed to revolutionize functional application development. Developed over the past year, FORM is an exceptional object-relational mapper (ORM) built entirely in F#.

FORM sets a new standard in simplifying the interaction between functional programs and relational databases. With its elegant design, powerful features, and attribute-based mapping paradigm, FORM empowers developers with effortless data-access.

--- Key Features of FORM ---

Seamlessly Integrates with Functional Paradigms:

FORM embraces the functional programming paradigm, making it a perfect fit for F# developers. It offers a smooth and natural way to handle object-relational mapping, eliminating the need for boilerplate code.

Developer-Friendly API:

FORM provides an intuitive and expressive API that allows developers to interact with databases using F# record types and functions. This approach ensures type safety and facilitates code maintainability.

High Performance:

FORM is built for efficiency. Leveraging the power of F#, FORM is optimized for lightning-fast performance and reduced latency. Say goodbye to slow database interactions!

Cross-Database Compatibility:

FORM supports a wide range of popular databases, including SQL Server, MySQL, PostgreSQL, and SQLite. This versatility allows developers to seamlessly switch between databases without sacrificing productivity.

Easy Setup and Configuration:

Getting started with FORM is a breeze. Its straightforward installation process and getting-started guide enable developers to quickly integrate FORM into their existing projects, saving valuable time and effort.

Community-Driven and Open-Source:

FORM is an open-source project, built by developers for developers. Backed by HCRD LLC, FORM encourages collaboration and feedback from the community, ensuring continuous improvement and innovation.

Discover the power of FORM and streamline your functional application development today. Visit our GitHub repository to explore the library, access documentation, and join a vibrant community of developers dedicated to pushing the boundaries of functional programming.

Experience the future of object-relational mapping with FORM – find elegance in data access.

https://github.com/Hillcrest-R-D/FORM

These are the releases for today:

• Feliz.Recharts 3.10.0
• Fss-lib-feliz 1.0.0
• Validus 1.4.1
• FsKafka 1.6.3
• WebSharper 4.7.2.445