- ghc-devs - Haskell.org

GHC 9.10.3-rc4 is now available
by Zubin Duggal 18 Aug '25

18 Aug '25

The GHC developers are very pleased to announce the availability of the fourth release candidate for GHC 9.10.3. Binary distributions, source distributions, and documentation are available at [downloads.haskell.org][] and via [GHCup](https://www.haskell.org/ghcup/). GHC 9.10.3 is a bug-fix release fixing over 50 issues of a variety of severities and scopes. A full accounting of these fixes can be found in the [release notes][]. As always, GHC's release status, including planned future releases, can be found on the GHC Wiki [status][]. The changes from the third release candidate are: - A fix for a rare segfault with code involving STM (#26205) - A fix for the `naturalAndNot` returning bogus results (#26205) - A fix for a crash in the renamer (#25056) This release candidate will have a two-week testing period. If all goes well the final release will be available the week of 1 September 2025. We would like to thank Well-Typed, Tweag I/O, Juspay, QBayLogic, Channable, Serokell, SimSpace, the Haskell Foundation, and other anonymous contributors whose on-going financial and in-kind support has facilitated GHC maintenance and release management over the years. Finally, this release would not have been possible without the hundreds of open-source contributors whose work comprise this release. As always, do give this release a try and open a [ticket][] if you see anything amiss. [release notes]: https://gitlab.haskell.org/ghc/ghc/-/blob/ghc-9.10/docs/users_guide/9.10.3-… [status]: https://gitlab.haskell.org/ghc/ghc/-/wikis/GHC-status [downloads.haskell.org] https://downloads.haskell.org/ghc/9.10.3-rc4 [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new

1 0

CI failures
by Ben Gamari 17 Aug '25

17 Aug '25

Hi all, This morning I found that one of the core services running on gitlab.haskell.org had crashed due to an out-of-memory condition. This resulted in a number of spurious CI failures. I have restarted a few but don't hesitate to restart any that I may have missed. Cheers, - Ben

1 0

9.14 progress update
by Andreas Klebinger 12 Aug '25

12 Aug '25

I'm merely forwarding this from ghc-releases for those not following there: Hi all, A brief update on the GHC 9.14 release status. As noted last time, the release process has been held up by a few significant bodies of on-going work: - the upgrade of the Windows toolchain which has revealed a number of linking issues, - enabling support for LLVM 20 (#26267), along with the resolution of a few correctness issues which were uncovered in the process (#26109) - the resolution to #23109, a rather invasive correctness fix which we want to ensure is adequately tested prior to the release, At this point we have resolved, or are close to resolving, all of these issues. We expect that #23109 will land today, with the resolution to #26109 hopefully landing shortly thereafter. One wrinkle here is a late request for a boot library bump (#26268) which has had a number of knock-on effects. We are still trying to land this in `master`; we tentatively plan to backport but given how the state of the release process we will not delay the release if things do not go smoothly. Once the above has happened we will backport to `ghc-9.14` and begin preparation of the first alpha release. This may happen as soon as Thursday. Cheers, - Ben

3 3

Proposal: Roundtrip serialization of Cmm (parser-compatible pretty-printer output)
by Diego Antonio Rosario Palomino 11 Aug '25

11 Aug '25

>Hi Diego, >In the future it would make things easier if you could use one of the >common email quoting conventions (i.e. starting lines with >). It is >otherwise a bit hard to distinguish your replies from the questions >you are responding to. I am sorry, Ben Gamari. I am not used to working in mailing lists. I also messed up the formatting in my last reply. I accidentally created a second topic (but this comment uses the original topic). Please tell me if this comment uses an appropriate format so I can proceed to answer the rest of your reply. Btw, some months back my first topic on this mailing list just linked to the corresponding Discourse post: https://discourse.haskell.org/t/gsoc-2025-documenting-and-improving-cmm/118… Would it be acceptable to use Discourse for my next topic regarding this project? (Maybe with a link here, on this mailing list.) Diego Antonio Rosario Palomino

2 3

GHC 9.10.3-rc3 is now available
by Zubin Duggal 08 Aug '25

08 Aug '25

The GHC developers are very pleased to announce the availability of the third release candidate for GHC 9.10.3. Binary distributions, source distributions, and documentation are available at [downloads.haskell.org][] and via [GHCup](https://www.haskell.org/ghcup/). GHC 9.10.3 is a bug-fix release fixing over 50 issues of a variety of severities and scopes. A full accounting of these fixes can be found in the [release notes][]. As always, GHC's release status, including planned future releases, can be found on the GHC Wiki [status][]. The changes from the second release candidate are: - Reverting a change the exports of the `Backtrace` constructor in the base library that was backported due to confusion on CLC approvals (!14587) - Reverting a change to the configure script (!14324) that dropped probing for ld.gold This release candidate will have a two-week testing period. If all goes well the final release will be available the week of 22 August 2025. We would like to thank Well-Typed, Tweag I/O, Juspay, QBayLogic, Channable, Serokell, SimSpace, the Haskell Foundation, and other anonymous contributors whose on-going financial and in-kind support has facilitated GHC maintenance and release management over the years. Finally, this release would not have been possible without the hundreds of open-source contributors whose work comprise this release. As always, do give this release a try and open a [ticket][] if you see anything amiss. [release notes]: https://gitlab.haskell.org/ghc/ghc/-/blob/ghc-9.10/docs/users_guide/9.10.3-… [status]: https://gitlab.haskell.org/ghc/ghc/-/wikis/GHC-status [downloads.haskell.org] https://downloads.haskell.org/ghc/9.10.3-rc3 [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new

3 2

GHC 9.10.3-rc2 is now available
by Zubin Duggal 06 Aug '25

06 Aug '25

The GHC developers are very pleased to announce the availability of the second release candidate for GHC 9.10.3. Binary distributions, source distributions, and documentation are available at [downloads.haskell.org][] and via [GHCup](https://www.haskell.org/ghcup/). GHC 9.10.3 is a bug-fix release fixing over 50 issues of a variety of severities and scopes. A full accounting of these fixes can be found in the [release notes][]. As always, GHC's release status, including planned future releases, can be found on the GHC Wiki [status][]. The changes from the first release candidate are: - Bumping the text submodule to 2.1.3 - Reverting a bug fix (!14291) that restricted previously allowed namespace specifiers (#26250) - Reverting the bump of the deepseq submodule to 1.5.2.0 (#26251) This release candidate will have a two-week testing period. If all goes well the final release will be available the week of 19 August 2025. We would like to thank Well-Typed, Tweag I/O, Juspay, QBayLogic, Channable, Serokell, SimSpace, the Haskell Foundation, and other anonymous contributors whose on-going financial and in-kind support has facilitated GHC maintenance and release management over the years. Finally, this release would not have been possible without the hundreds of open-source contributors whose work comprise this release. As always, do give this release a try and open a [ticket][] if you see anything amiss. [release notes]: https://gitlab.haskell.org/ghc/ghc/-/blob/ghc-9.10/docs/users_guide/9.10.3-… [status]: https://gitlab.haskell.org/ghc/ghc/-/wikis/GHC-status [downloads.haskell.org] https://downloads.haskell.org/ghc/9.10.3-rc2 [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new

1 0

Generating fresh names in a source plugin
by Wolfgang Jeltsch 05 Aug '25

05 Aug '25

[Since it seems that `glasgow-haskell-users(a)haskell.org` is essentially an announcements-only mailing list these days, I’m re-sending my recent e-mail to that mailing list here.] Hello! I want to generate AST fragments in a source plugin, and for this I need to generate fresh (local) names. My current approach is to use `mkSystemName`, but it, like many of the other name-generating operations, needs a value of type `Unique`. How can I generate such values? It seems that the `Hsc` monad doesn’t carry a value of type `UniqueSupply` with it. All the best, Wolfgang

5 14

Re: GHC/ | Failed pipeline for wip/T23109 | a90f83d4
by Simon Peyton Jones 31 Jul '25

31 Jul '25

Dear GHC devs This mr !10479 seems Utterly Broken. Looks as if something is wrong with CI. Can anyone help? https://gitlab.haskell.org/ghc/ghc/-/merge_requests/10479 Thanks Simon On Wed, 30 Jul 2025 at 09:05, GitLab <gitlab(a)gitlab.haskell.org> wrote: > [image: GitLab] > [image: ✖] Pipeline #113076 has failed! > > Project Glasgow Haskell Compiler <https://gitlab.haskell.org/ghc> / GHC > <https://gitlab.haskell.org/ghc/ghc> > Branch > wip/T23109 <https://gitlab.haskell.org/ghc/ghc/-/commits/wip/T23109> > Commit > a90f83d4 > <https://gitlab.haskell.org/ghc/ghc/-/commit/a90f83d44ae1ad0eee63f24ff62568e…> > in !10479 <https://gitlab.haskell.org/ghc/ghc/-/merge_requests/10479> > Fix mergo bugs > Commit Author > Simon Peyton Jones <https://gitlab.haskell.org/simonpj> > > Pipeline #113076 <https://gitlab.haskell.org/ghc/ghc/-/pipelines/113076> > triggered by Simon Peyton Jones <https://gitlab.haskell.org/simonpj> > had 7 failed jobs > Failed jobs > [image: ✖] tool-lint lint-submods > <https://gitlab.haskell.org/ghc/ghc/-/jobs/2241378> > [image: ✖] tool-lint lint-linters > <https://gitlab.haskell.org/ghc/ghc/-/jobs/2241373> > [image: ✖] tool-lint typecheck-testsuite > <https://gitlab.haskell.org/ghc/ghc/-/jobs/2241374> > [image: ✖] packaging project-version > <https://gitlab.haskell.org/ghc/ghc/-/jobs/2241326> > [image: ✖] tool-lint lint-testsuite > <https://gitlab.haskell.org/ghc/ghc/-/jobs/2241375> > [image: ✖] tool-lint ghc-linters > <https://gitlab.haskell.org/ghc/ghc/-/jobs/2241376> > [image: ✖] tool-lint lint-author > <https://gitlab.haskell.org/ghc/ghc/-/jobs/2241377> > [image: GitLab] > You're receiving this email because of your account on gitlab.haskell.org. > Manage all notifications > <https://gitlab.haskell.org/-/profile/notifications> · Help > <https://gitlab.haskell.org/help> >

2 4

GHC 9.10.3-rc1 is now available
by Zubin Duggal 30 Jul '25

30 Jul '25

The GHC developers are very pleased to announce the availability of the release candidate for GHC 9.10.3. Binary distributions, source distributions, and documentation are available at [downloads.haskell.org][] and via [GHCup](https://www.haskell.org/ghcup/). GHC 9.10.3 is a bug-fix release fixing over 50 issues of a variety of severities and scopes. A full accounting of these fixes can be found in the [release notes][]. As always, GHC's release status, including planned future releases, can be found on the GHC Wiki [status][]. This release candidate will have a two-week testing period. If all goes well the final release will be available the week of 11 August 2025. We would like to thank Well-Typed, Tweag I/O, Juspay, QBayLogic, Channable, Serokell, SimSpace, the Haskell Foundation, and other anonymous contributors whose on-going financial and in-kind support has facilitated GHC maintenance and release management over the years. Finally, this release would not have been possible without the hundreds of open-source contributors whose work comprise this release. As always, do give this release a try and open a [ticket][] if you see anything amiss. [release notes]: https://gitlab.haskell.org/ghc/ghc/-/blob/ghc-9.10/docs/users_guide/9.10.3-… [status]: https://gitlab.haskell.org/ghc/ghc/-/wikis/GHC-status [downloads.haskell.org] https://downloads.haskell.org/ghc/9.10.3-rc1 [ticket]: https://gitlab.haskell.org/ghc/ghc/-/issues/new

2 1

Fwd: Proposal: Roundtrip serialization of Cmm (parser-compatible pretty-printer output)
by Diego Antonio Rosario Palomino 28 Jul '25

28 Jul '25

---------- Forwarded message --------- De: Diego Antonio Rosario Palomino <diegorosario2013(a)gmail.com> Date: lun, 28 jul 2025 a la(s) 12:56 p.m. Subject: Re: Proposal: Roundtrip serialization of Cmm (parser-compatible pretty-printer output) To: Hécate <hecate(a)glitchbra.in> Hello all, Thank you for the thoughtful responses so far, and thank you Simon for summarizing Andreas's comments. *"Do you have any use-cases in mind? Suppose you were 100% successful — would anyone use it?"* Yes — my mentor, *Csaba Hruska*, would. He's currently working on a custom STG optimizer that uses experimental techniques to enable whole-program optimizations for Haskell code. The intended pipeline is: *GHC STG → custom optimizer → textual Cmm → code generation* However, the current *parseable* Cmm is not sufficient for his use case, because it *cannot represent everything the Cmm AST can express*. Beyond this specific use case, achieving *roundtrip serializability* for Cmm could make it a *viable alternative to LLVM* for Haskell projects. Native code generation via Cmm is much faster than through LLVM. And while outputting LLVM from Cmm currently produces *less performant* code than directly targetting LLVM, I believe the inefficiencies could be fixed relatively easily. Enabling such improvements is part of the motivation for my documentation work — to help developers understand and work with Cmm and its infrastructure. *"You need a compelling reason to change the input language (understood by the parser) since libraries may include .cmm files, which will break. (It'd be interesting to audit Hackage to see how many libraries do include such .cmm files.)"* To clarify, this proposal would *not* break backwards compatibility. There are two implementation paths: 1. Introduce a *second parser* that accepts a syntax 100% identical to the pretty printer output. 2. Extend the *current parser* by adding a mode (or block) that uses a distinct keyword (e.g., low_level_unwrapped) to indicate: "expect exact syntax, no convenience fills." In either case, existing .cmm files would continue to be supported as-is. The current parser wouldn't need features removed or changed — the new syntax would *only add capabilities*. *"It’s unclear from your example how those blocks would work exactly. Is low_level_unwrapped a label? If so can we goto it? Is it a keyword? Something else entirely?"* — Andreas Apologies for the confusion — I’m not well-versed in the formal terminology. To clarify: low_level_unwrapped (or very_low_level, or another name) would be a *keyword or syntactic construct* that tells the parser to interpret the contents of the block { ... } using a syntax *identical to what the pretty printer emits*. For example: function1 { } // existing low-level syntax function2() { } // existing high-level syntax very_low_level { ... } // new mode: code with exact pretty-printed syntax inside the block *"Rather than change the language understood by the parser, would it not be easier to change the language spat out by the pretty-printer to be compatible with the parser?"* Unfortunately, that’s not a practical path forward. At the start of the project, Csaba (my mentor) recommended leaving the parser mostly untouched and focusing instead on extending the pretty printer. However, we’ve realized that the differences between the parser and the pretty printer are not trivial. The parser — even in its current “low-level” mode — *inserts inferred data* via convenience functions. It *abstracts part of the structure*, meaning we cannot fully recover the original Cmm ADT just by parsing. In other words, *modifying the pretty printer to match the parser would require it to lose information* — which I strongly oppose. If Cmm is generated programmatically, the pretty-printed version would lack structural information present in the internal data structure. And parseable Cmm would still be *incapable of expressing all features of the AST*. I hope that also addresses your concern, Hécate. This GSoC project runs until *November 10th*. I was granted extra time since, unlike most participants, I’m not working through summer vacation — I’m in the Southern Hemisphere. (Also, I realize I previously used the wrong project name in this thread — the correct title of my GSoC project is *“Documenting and improving Cmm.”*) Regarding the risk of *bitrot* in a new parser or new syntax mode: one possible mitigation would be to add *regression tests* that check whether parsing a file and pretty-printing it results in compatible output. On a related note, I’ve noticed that *some Cmm examples in the documentation and even in source code comments are incorrect or outdated*. Part of my work includes identifying and correcting these inconsistencies. Thanks again to everyone for your time and input — I greatly appreciate the discussion and feedback. Best regards, *Diego Antonio Rosario Palomino* GSoC 2025 – Documenting and improving Cmm El lun, 28 jul 2025 a la(s) 11:04 a.m., Hécate via ghc-devs ( ghc-devs(a)haskell.org) escribió: > Hi Diego, > > Thank you very much for your work in this direction, it's sorely needed. > > I'm all for having proper roundtrip correctness for Cmm, but I am not sure > altering the parser is the way to go. > In my opinion, GHC should produce valid textual Cmm, that can be ingested > by the parser at it is today. > > Have a nice day, > Hécate > Le 28/07/2025 à 02:16, Diego Antonio Rosario Palomino a écrit : > > Hello GHC devs, > > I'm currently working on Cmm documentation and tooling improvements as > part of my Google Summer of Code project. One of my core goals is to make > Cmm roundtrip serializable. > > Right now, the in-memory Cmm data structure—generated programmatically > (e.g., from STG via GHC)—can be pretty-printed, and Cmm can also be parsed. > However, the pretty-printed version is not compatible with the parser. That > is, we cannot take the output of the pretty printer and feed it directly > back into the parser. > > Example: > > Parseable version: > > sum { > cr: > bits64 x; > x = R1 + R2; > R1 = x; > jump %ENTRY_CODE(Sp(0))[R1]; > } > > Pretty-printed version: > > sum() { // [] > { info_tbls: [] > stack_info: arg_space: 8 > } > {offset > cf: // global > _ce::I64 = R1 + R2; > R1 = _ce::I64; > call (I64[Sp + 0 * 8])(R1) args: 8, res: 0, upd: 8; > } > } > > Another example: > > Parseable version: > > simple_sum_4 { // [R2, R1] > cr: // global > bits64 _cq; > _cq = R2; > bits64 _cp; > _cp = R1; > R1 = _cq + _cp; > jump (bits64[Sp])[R1]; > } > > Pretty-printed version: > > simple_sum_4() { // [] > { info_tbls: [] > stack_info: arg_space: 8 > } > {offset > cs: // global > _cq::I64 = R2; > _cr::I64 = R1; > R1 = _cq::I64 + _cr::I64; > call (I64[Sp])(R1) args: 8, res: 0, upd: 8; > } > } > > While it’s possible to write parseable Cmm that resembles the > pretty-printed version (and hence the internal ADT), they don’t fully > match—mainly because the parser inserts inferred fields using convenience > functions. > > Proposal: > > To make roundtrip serialization possible, I propose supporting a new > syntax that matches the pretty printer output exactly. > > There are a couple of design options: > > 1. > > Create a separate parser that accepts the pretty-printed syntax. Files > could then use either the current parser or the new strict one. > 2. > > Extend the current parser with a dedicated block syntax like: > > low_level_unwrapped { > ... > } > > This second option is the one my mentor recommends, as it may better > reflect GHC developers' preferences. In this mode, the parser would not > insert any inferred data and would expect the input to match the > pretty-printed form exactly. > > This would enable a true roundtrip: > > - > > Compile Haskell to Cmm (in-memory AST) > - > > Pretty-print and write it to disk (wrapped in low_level_unwrapped { > ... }) > - > > Later read it back using the parser and continue with codegen > > Optional future direction: > > As a side note: currently the parser has both a “high-level” and a > “low-level” mode. The low-level mode resembles the AST more closely but > still inserts some inferred data. > > If we introduce this new “exact” low-level form, it's possible the > existing low-level mode could become redundant. We might then have: > > - > > High-level syntax > - > > New low-level (exact) > - > > And possibly deprecate the current low-level variant > > I’d be interested in your thoughts on whether that direction makes sense. > > Serialization libraries? > > One technically possible—but likely unacceptable—alternative would be to > derive serialization via a library like aeson. That would enable > serializing and deserializing the Cmm AST directly. However, I understand > that aeson adds a large dependency footprint, and likely wouldn't be > suitable for inclusion in GHC. > > Final question: > > Lastly—I’ve heard that parts of the Cmm pipeline may currently be under > refactoring. If that’s the case, could you point me to which parts (parser, > pretty printer, internal representation, etc.) are being modified? I’d like > to align my efforts accordingly and avoid conflicts. > > Thanks very much for your time and input! I'm happy to iterate on this > based on your feedback. > > Best regards, > Diego Antonio Rosario Palomino > GSoC 2025 – Cmm Documentation & Tooling > > _______________________________________________ > ghc-devs mailing listghc-devs@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs > > -- > Hécate ✨ > 🐦: @TechnoEmpress > IRC: Hecate > WWW: https://glitchbra.in > RUN: BSD > > _______________________________________________ > ghc-devs mailing list > ghc-devs(a)haskell.org > http://mail.haskell.org/cgi-bin/mailman/listinfo/ghc-devs >

3 2