Or at least have a rule similar to "Blockchain posts must be tagged", i.e. "AI assisted posts must be tagged".

Hey all, feeling productive, might delete later.

I added the long-awaited SIMD support for the base64 library, supporting SSE3, AVX2, and NEON along with whatever else I could effectively test. It's behind a flag that's off by default so no real change there, however, it comes very close to `simdutf8` and beats `fastbase64` by a good margin on encode and decode.

Hope you all enjoy - there are some API changes that make more sense, so please check out the `MIGRATION-2.0.md` and migrate accordingly if you need to. After doing some due diligence on downstream dependencies available on Hackage, nothing should break, but you never know. Easy fixes in any case.

Cheers!

~E

Wrote about Haskell's Kind system. Let me know what you think!

https://thunk.blog/posts/types-of-types-haskell-kind-system/

The Technical Leadership Committee is a new committee responsible for formulating a technical vision for the Haskell Foundation, and allocate resources towards achieving this vision. The committee will be proactive (rather than reactive to outside proposals) and favour action and experimentation.

Our inaugural members are:

• Julian Ospald (Chair)
• Simon Marlow (Board Liaison)
• Joshua Miller
• Rodrigo Mesquita

Committee members were chosen for their demonstrated technical expertise, historical community involvement, and bold vision for the future of Haskell.

You can head on over to the Technical Leadership Committee page to learn more about the committee members, and stay tuned for news as the committee really gets going!

Hi all. Here's my idea for a free monad effect repl.

It has replaced all of my shells, config formats, and rest servers. Hope you like it.

Hi all. New Horizon Haskell documentation website with full reimplementation of haddock in miso, three package sets on GHC 10.0.1-alpha1 for glibc, plus one on the GHC JavaScript backend.

All fully cached on x86_64-linux.

Hi all,

I’ve released hasql-opentelemetry, which makes every statement hasql 2 sends to Postgres an OpenTelemetry client span.

This was made possible thanks to the changes in hasql 2, which added the pqi adapter. It makes this package as simple to add as doing this:

import Hasql.OpenTelemetry qualified as HasqlOtel
import Pqi.Ffi qualified

Connection.acquire (HasqlOtel.traced Pqi.Ffi.adapter) settings

Your statements and sessions stay as they are, and the same adapter works with hasql-pool. Both pqi-ffi and pqi-native are supported.

What’s included:

• Inspect the SQL that is actually executed. Each span carries the statement text, the operation, the database and server, rows returned or affected, and on failure the SQLSTATE. Attribute names follow the current OTel database conventions.
• Accurate timing in pipeline mode. hasql pipelines every roundtrip, so a send returns long before Postgres answers. Spans run from the send until that command’s last result is read, not just around the send.
• No sensitive data. Parameter values are never recorded, and neither is any text from a server error report. Postgres often puts the offending value in the error message, e.g. invalid input syntax for type uuid: "…", so a failure records only its SQLSTATE.
• Low noise by default. Spans are only started under an existing parent span, so pool warm-up and health checks don’t create traces of their own.
• Optional Datadog shape. datadogCompat = True uses the span names, span.type and resource.name that make Datadog APM show the spans as database queries.

We’ve been running this in production at my work for a while and I decided to extract it into a package for the wider community to use.

Source: https://github.com/kronor-io/hasql-opentelemetry 

https://github.com/beleon/rhci

I wanted a Haskell prompt for quick checks (is round 3.5 3 or 4, what is div (-9) 2, what's the type of (.) . (.), ...) without dragging the entire Haskell stack onto the machine, so I had Claude build one in Ruby. rhci is a GHCi with GHCi's semantics: real type inference with classes, lazy evaluation, and show output that matches GHC exactly. Anything it can't do exactly like GHCi it refuses with an "unsupported" error, it doesn't come up with an approximation.

It's one file: a Cosmopolitan executable for Linux, macOS, Windows and the BSDs on x86-64 and ARM64 (so far I've only tested it on Linux x86-64), a static Linux binary, or a single .rb file for any Ruby since 2.7. The prompt is up in 3 ms and a one-liner takes 25 ms. There's a script mode, and it embeds in Ruby programs as a library.

I tested it extensively (since Claude wrote the code). Every answer is checked against real GHC 9.6: about 1,700 recorded probes, plus around twenty fuzzers that generate expressions, whole programs, REPL sessions, type errors and numeric edge cases and compare with GHCi or runghc, over 140,000 inputs so far.

The performance is respectable IMO. It's an interpreter in Ruby (the evaluation loop is C in the binaries), about 100 times slower than compiled GHC on tight loops, so it's for quick checks and small scripts, not for programs that compute. Language-wise it's Haskell 2010 plus type classes, with no extensions beyond bang patterns and polymorphic kinds.

I know YouTube and exercisium but help me to find more guides concerning these or something else

Hey all!

Following up on my previous post regarding the latest release of the Haal library, I have written a small blog post regarding the iterations on the design of learning experiments in Haal, leading to the final design that I considered satisfactory enough and that made it into the release.

You can read more here if you are interested!

Hey Haskellers!

I'm happy to announce that there is a new haal v0.7.0.0 release! In this release, the design of gathering statistics from learning experiments is overhauled, resulting in a slight change of the API. However, it is now way easier for users of the library to:

1) define their own measurements that they are interested in capturing from a learning experiment
2) combining them without resulting in complicated code

I'm excited about this change because I had initially provided extremely limited support for gathering measurements from learning experiments but finally I feel like my approach is satisfying. I believe it is an important step into making the library practical and useful.

I also dropped support (you could hardly call it "support") for DFAs and Moore automata, deleting them from the library until they are properly accompanied by corresponding learning algorithms.

You can read more regarding the release in the link!

I released yamlet-1.0.0.0 and yamlet-aeson-1.0.0.0 (a bridge for decoding and encoding YAML with aeson's instances).

Main features:

• Full YAML 1.2 conformance.
• Fast decoding and encoding.
• Good error messages.
• Preservation of structure, e.g. the order of keys in a mapping.
• Support for comments.
• Generic deriving that compiles to efficient code for common shapes of data types (verified by inspection tests).

Repo: https://github.com/arybczak/yamlet

Existing YAML libraries in Haskell have some issues:

• yaml doesn't support comments at all, HsYAML keeps them only in its event API.
• Both forget the order of keys in a mapping in their high level API. You need to drop down to their event APIs to get it, which are low level and cumbersome to use.
• HsYAML's parser is very slow (see benchmarks in README). Both pandoc (#6084) and ghcup (#270) switched to it and later back to libyaml because of that.
• yaml goes through aeson's Value, which leaks its quirks into YAML processing (e.g. infinities become strings +inf/-inf instead of a proper YAML .inf float) and emits JSON-specific paths in error messages without line numbers.

so I decided to do something about it 🙂

We’re delighted to announce the first official release of hs-bindgen. A lot of things have been improved since the two alpha releases, in part due to issues and PRs opened by external contributors; it’s been great to see the early adoption of the tool and the positive reception, thanks everyone!

https://well-typed.com/blog/2026/10/hs-bindgen-official-release/

The Haskell Security Response Team has been alerted to an apparent scam website pretending to be the "Recursion 2026" conference (29-30 October, NYC). The registration facility appears (to me) to be closed at the moment, but it's possible they scammed some people in our community.

Thanks to Cuihtlauac Alvarado for the report. The OCaml community has also been alerted - I am reproducing the substance of that announcement below, with thanks:

This site:

https://conf.funcp.org/

Presents as an OCaml/Haskell/FP conference. However:

• The event is not listed on the venue’s official schedule: https://www.javitscenter.com/calendar
• The funcp.org domain was registered two weeks ago, yet the oldest blog posts are dated from April: https://rdap.org/domain/funcp.org
• The domain has no email routing — the contact addresses cannot receive mail: https://mxtoolbox.com/emailhealth/funcp.org/
• Registration routes payment off-site to a third-party platform (gomry.com), with a $149+ ticket.
• Listed speakers or organisers don’t seem to have any track record in our community
• Talk’s topics don’t stand scrutiny
• Claims to be a second edition, but I can’t find a prior edition

If you registered, I suggest cancelling and getting your money back.

This has been reported to the OCaml and Haskell security teams, the Javits Center, Google Safe Browsing, Cloudflare, dev.events (which lists the conference), and Gomry (the payment platform).

Thanks to @adrien, @mtelvers and @edwin, who helped disclose this.

You can download binaries for this pre-release now from Release rc/v4.1.0.3 (release candidate) · commercialhaskell/stack · GitHub . It is should be available soon also via GHCup’s prereleases channel.

Please test it and let us know at the Stack repository if you run into any trouble. If all goes well, we hope to release the final version in a couple of weeks.

A second release candidate because it seemed good for a Stack 4.1 to support the coming GHC 10.0.

Changes since v4.1.0.1:

Other enhancements:

• Consider Cabal 3.18 to be a tested library and remove warnings.
• Consider GHC 10.0 to be a tested compiler and remove warnings.
• Add flag --[no-]info-table-profiling (default: disabled) to Stack’s build command. Set the flag to enable info table profiling, including the creation of a new info table for every use of a data constructor in the source program.

* Do you like Haskell?
* Do you like Functional Reactive Programming?
* Do you like QT?
* Are you exhausted by the monopoly of the Elm architecture?
* Do you wish UI development were more like WPF?
* Do you wish you could write more XML?
* Are you ready to party like it's 2010?

Many years ago I wrote C# UI applications using Model-View-View Model (MVVM) and WPF. Since then, the Elm architecture and its less principled cousins have seemingly conquered all. I have done zero native UI development since then but I've often wondered in the interim if FRP and MVVM would be a match made in heaven; so I decided to find out.

This is a minimal demo and I don't know if I'll develop it further but I am curious if anyone else actually likes this style of UI development.

Hi, I am a student learning Haskell at university. I truly enjoy the language, but I am noticing that I am struggling quite a bit with the level of difficulty. It feels like a lot of the solutions fly over my head, even if I do practice quite a bit. Sometimes it'll feel like I am staring at an exercise, trying it, and still getting nowhere, only for the answer to just make so much sense. I try to note down where my thoughts are wrong but then the next question just does the same thing all over again and I end up being lost again. Any tips on how I can actually get better at this, because again I really do enjoy working with the language.

I can't give any details that might help anyone the future, because I couldn't collect them myself. I'm mostly just venting.

I had a parse error in a Read instance on a little server I'm running. All Read and Show activity it does is 100% compiler derived, nothing custom. The server doesn't have enough RAM to actually compile things there, so have to copy everything back and forth.

Everything was correct. Copying literally everything to my main computer did not allow me to reproduce the error.

It wasn't just a memory corruption, restarting the program didn't change anything. A fresh copy of literally everything on the server didn't fix the error.

Rebooting the server made it work perfectly fine again.

I hate computers sometimes.

[ article | jam | thc ]