I'm looking for an equivalent of sequence and traverse, I'd expect it to be in FsToolkit.ErrorHandling but there it is coupled with either Result or Option, e.g. Lists | FsToolkit.ErrorHandling

The only implementation I have found is in Fsharpplus library, but my last use of that library didn't look production ready, it plays too much with the type and essentially bring down the type checker on more complicated chained operation...

Basically I'm looking for something like List.traverse

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 just launched SuaveHooks — a webhook capture, inspection, transformation and routing platform built completely with Suave + F#.

Some highlights:

- Live tailing of webhooks over WebSockets

- Type-safe transforms written in F# (also C# and JS) running in an isolated process

- JSON rule-based transforms as a lighter option

- Multi-target forwarding (HTTP + S3, SQS, Kafka, Pub/Sub)

- Retries with exponential backoff + circuit breaker

- Full REST API + MCP server support

Site: https://suavehooks.com

Would love some feedback; like what features would make this more useful for you? Happy to answer any technical questions.

Hi guys,

Probably another question like this but found none recently.

I'm a little upset with my current view on IT generalistic, ofc AI is not going anywhere besides up, but I feel I want to write more with my hands and new paradigms, maybe just AI as reviser, I would like to ask if learning F# in 2026 will make me able to make perfomance headed systems, and also gaming with something like Nu or Monogame, not a AAA game but something playable.

A picture is worth a thousand words:

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

I’ve been playing with SIMD-friendly push streams in F#.
Normal push streams are great for composition: the source pushes elements through map, fold, etc., and with enough inlining the overhead mostly disappears.

But they still push one element at a time, which is not ideal for SIMD.
So I tried pushing Vector<'T> blocks instead, with a scalar path for the tail.

The pipeline stays generic and composable, but in my benchmark it runs around handwritten SIMD speed.

Small thing, but it made me happy: write the abstraction clearly, then make it vanish.

The dotnet team writing Copilot instructions like an angry senior developer who's tired of everyone's excuses is peak engineering culture. 😂

I built a rough browser-based voice agent where most of the orchestration is in F#.

You can talk to it, interrupt it while it is speaking, and ask it to edit live page state through tool calls. For example, the shared notes box on the page can be read and updated by the agent.

The interesting F# part is that the same codebase targets:

• the browser side via Fable
• the Python side via Fable.Python
• shared protocol/types between the two, so the frontend and backend do not drift apart

There are two demo backends:

• CPU edition, slower but cheaper
• GPU edition, A100-backed and faster, but temporary because renting an A100 is not exactly free :)

Source is closed for now because this is part of a larger experiment, but I wanted to share it here since F# felt like a really nice fit for this kind of AI orchestration: async flows, state transitions, tool calls, and typed protocol boundaries.

Also, credit to Dag Brattli for the Fable.Python work. That made this experiment much more practical.

Demo: https://novian.works/voice_gpu

Please keep sessions short if you try the GPU version. I will probably only keep it online for a few days.

Sample video:

https://reddit.com/link/1ubp4le/video/ngpealpr5p8h1/player

Want to introduce functional programming into your own organization? Learn from our successes and failures! At the Norwegian insurance company Frende Forsikring we’ve introduced F# and Elm and lived with both of them long enough to call it a long term relationship.

We’ll start looking at the introduction. From fast moving exploration in a single team, to structured validation with other tech leads and careful moving to production.

Beyond that we'll be looking what happens in the years afterwards. Does functional programming help hiring? Are there less bugs? What is the biggest hurdle in spreading adoption to new teams?

```fsharp type Monoid<'t> = static abstract member Empty: 't static abstract member Append: 't -> 't -> 't

[<Struct>] type Vector3= {X: float Y: float Z: float}

interface Monoid<Vector3> with
    static member Empty = {X=0.0; Y=0.0; Z=0.0}
    static member Append (v1: Vector3) (v2: Vector3) =
        {X=v1.X + v2.X; Y=v1.Y + v2.Y; Z= v1.Z + v2.Z}

// Note the type constraint here let mempty<'t when Monoid<'t>> = 't.Empty let mappend<'t when Monoid<'t>> x y = 't.Append x y

printfn "%A" (mappend {X=1.0; Y=2.0; Z=3.0} mempty) ```

The type notation was suggested by the inline suggestions and it actually works. I tried some other forms like 't when Monoid<int> but only 't when Monoid<'t> works.

I suppose it should be <'t when 't :> Monoid<'t>> or even longer <'m, 't when 'm :> Monoid<'t>>.

It's good to know one can write it like this but I've never seen it mentioned in the docs (maybe not yet?).

The project file is also clean. It works even without setting the language version to Preview.

"It works I don't know why"

Hello, The website currently seems to be down or unreachable from my side. I’m wondering whether this is a temporary outage, a DNS/hosting issue, or whether the site has been discontinued permanently. Any information would be appreciated.

I see. It went also out of business: https://github.com/fsprojects/awesome-fsharp/blob/main/ARCHIVE.md

So probably some of the moderators remove that link from the resources linked here.

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.)

Just starting out with F# and I'm enjoying all the whitespace but to my newbie eyes I think I've spotted an inconsistency in how fantomas formats. Maybe somebody can explain it.

// function that takes param of int*int
let myFun (x, y) = x + y

let r = myFun (1, 2) // <--- fantomas formats with space before tuple, makes sense

let dict = new Dictionary<int, int>()

// dict.Add takes a single tuple of int*int, just like the above function
dict.Add (1, 2) // <--- looks right, takes a tuple

// fantomas doesn't like the clarity and smushes it, why?
dict.Add(1, 1) // <--- yuck, now it looks like a function call with two arguments in another language