The Curious Engineer

All blogs / Dev tools / editors / IDEs

Tweag

tweag.io

Engineering blog from Tweag

Dev tools / editors / IDEsHaskellFunctional / PL theoryDevOps / SRE / infrastructure

’15’16’17’18’19’20’21’22’23’24’25’26
Posts
328 from 8 Sep 2015 to 29 Oct 2026
Posting
weekly (27 in the last year)
Kind
company blog
Feed
https://www.tweag.io/rss.xml

2026 20

  1. Running local development services
  2. Adopting Nickel in CodeCommons
  3. How to set up and run a Nixpkgs team
  4. Tricorder MCP server: feedback your agent won't forget
  5. Restoring type class support in Liquid Haskell
  6. Are we formal proofs yet? On formal proofs of programs with coding agents
  7. Five years of Cardano smart-contract audits: a retrospective
  8. Topiary: Formatting Forests
  9. Sheaves in Haskell
  10. Writing static checks to an unsuspecting library with Liquid Haskell
  11. Intersect Proposals 2026-2027 (revised)
  12. Intersect Proposals 2026-2028
  13. A statement from Tweag by Modus Create to the Cardano community
  14. 𝕯𝖔𝖈 𝖎𝖙 𝖑𝖎𝖐𝖊 𝖎𝖙'𝖘 𝖍𝖔𝖙
  15. Accessing external resources reliably with Bazel
  16. Nickel since 1.0
  17. How I learnt to stop worrying and love AI
  18. Integrating Coverity static analysis with Bazel
  19. Streamlining CodeQL Analysis with CodeQL Wrapper
  20. The quest for grammar combinators: introducing the Pup library

2025 31

  1. Announcing rules_img: a faster path to container images in Bazel
  2. In memoriam: Alexander Esgen
  3. The anatomy of a dependency graph
  4. The History of History Expiry
  5. Shrinking while linking
  6. Tweag@BazelCon2025
  7. Migrating to Bazel symbolic macros
  8. Single-line and multi-line formatting with Topiary
  9. Managing dependency graph in a large codebase
  10. Qualified Imports and Alias Resolution in Liquid Haskell
  11. Introduction to the dependency graph
  12. CodeQL: code organization, metadata, and running in CI
  13. Getting started with CodeQL, GitHub's declarative static analyzer for security
  14. Integrating Nix and Buck2
  15. Publish all your crates everywhere all at once
  16. Bazel workshop made public
  17. Intersect Proposals 2025 - Part 2
  18. Intersect Proposals 2025
  19. Why we blog
  20. Come meet us at VoxxedDays Luxembourg 2025
  21. The minimal megaparsec tutorial
  22. Frontend live-coding via ghci
  23. Practical recursion schemes in Rust: traversing and extending trees
  24. Come meet us at DevLille 2025
  25. A hundred pull requests for Liquid Haskell
  26. Bazel and Testwell CTC++, revisited
  27. Evaluating the evaluators: know your RAG metrics
  28. From minimal skeletons to comprehensive transactions with cooked-validators
  29. Bashfulness
  30. The refactoring of a Haskell codebase
  31. Writing a formatter has never been so easy: a Topiary tutorial

2024 21

  1. GHC's wasm backend now supports Template Haskell and ghci
  2. Introducing rules_gcs
  3. Python Packaging in the Real World: Biomedical projects vs. PyPI
  4. Reflecting away from definitions in Liquid Haskell
  5. Adding algebraic data types to Nickel
  6. Deploying Buildbarn on Kubernetes with mTLS on the side
  7. Programming Languages & Compilers Activity Report - Q2 2024
  8. Let there be types: observable type sharing for GHC Core
  9. Nickel modules
  10. Safe composable Python
  11. Liquid Haskell through the compilers
  12. LLM-based work summaries with work-dAIgest
  13. Nickel: Toward a Programmable LSP for Configurations
  14. The right words in the right place
  15. Re-implementing the Nix protocol in Rust
  16. Cloud Native Computing in 2024—feeling the pulse at Kubecon
  17. Software Identifiers through the eyes of Nix
  18. Extending destination-passing style programming to arbitrary data types in Linear Haskell
  19. Bazel remote execution with rules_nixpkgs
  20. Evaluating Retrieval in RAGs: A Gentle Introduction
  21. A look under GHC's hood: desugaring linear types

2023 44

  1. BazelCon Community Day - Munich
  2. Source filtering with file sets
  3. Separating debug symbols from executables
  4. Organist: stay sane managing your development environments
  5. Integrating Testwell CTC++ with Bazel
  6. Great Nickel configurations from little merges grow
  7. nixtract 0.1.0
  8. JSON Schemas to Nickel contracts
  9. rhine-bayes: a library for online reactive Bayesian inference
  10. CLI User Experience Case Study: Topiary
  11. Behind the scenes with FawltyDeps v0.13.0: Matching imports with dependencies
  12. Supercharging your Rust static executables with mimalloc
  13. Building a Rust workspace with Bazel
  14. How to Prevent GHC from Inferring Types with Undesirable Constraints
  15. Python Monorepo: an Example. Part 2: A Simple CI
  16. A Tour Around Buck2, Meta's New Build System
  17. Packaging Topiary in OPAM
  18. Assumptions for Liquid Haskell in the large
  19. Coverage-guided fuzzing of Haskell programs for cheap
  20. Announcing halide-haskell - a Haskell interface for the Halide image and array processing language
  21. Testing Control-Flow Translations in GHC
  22. Announcing Tf-Ncl 0.1
  23. Functional Python, Part III: The Ghost in the Machine
  24. Announcing Nickel 1.0
  25. A journey through the auditing process of a smart contract
  26. Announcing Skyscope
  27. Type-safe data processing pipelines
  28. Processing medical images at scale on the cloud
  29. crem: compositional representable executable machines
  30. Python Monorepo: an Example. Part 1: Structure and Tooling
  31. Linear Constraints: the problem with scopes
  32. Announcing FawltyDeps - a dependency checker for your Python code
  33. Announcing Topiary
  34. Chainsail: Now Unchained and Open-Source
  35. Taking the pulse of infrastructure management in 2023
  36. opam-nix: Nixify Your OCaml Projects
  37. smtlib-backends: faster SMT-LIB-based Haskell interface to SMT solvers
  38. Running a NixOS VM on macOS
  39. announcing jupyenv 0.1.0
  40. A Semester of HLS: An Internship Report
  41. Linear Constraints: the problem with O(1) freeze
  42. Nix with; with Nickel
  43. Functional Python, Part II: Dial M for Monoid
  44. Haskell at Work

2022 58

  1. Making GHC faster at emitting code
  2. Announcing Nickel 0.3.1
  3. Bazel and Nix: A Migration Experience
  4. Optimizing NixOS Search
  5. Creating a Delta Lake in Haskell with Sparkle
  6. Higher-orderness is first-order interaction
  7. Threads and messages with Rust and WebAssembly
  8. WebAssembly backend merged into GHC
  9. JupyterWith Next
  10. Staged programming with typeclasses
  11. Reinforcement Learning for Open Games
  12. Functional programming from sets and functions
  13. Recompilation avoidance in rules_haskell
  14. Hard user separation with NixOS
  15. A nub in the haystack
  16. Implementing Bayesian Replica Exchange in Chainsail
  17. Converting a polyglot project build to Bazel: part 1
  18. Improving the Probabilistic Programming Language monad-bayes
  19. Testing stateful systems, part two: Linear Temporal Logic
  20. Worry-free NixOS refactors
  21. Bazel rules to test Bazel rules
  22. Four months into The Nix Book
  23. Building Nix flakes from Rust workspaces
  24. Optimizing Nickel's Array Contracts
  25. How to keep a Bazel project hermetic?
  26. Construction and analysis of the build and runtime dependency graph of nixpkgs
  27. Functional Python, Part I: Typopædia Pythonica
  28. Unit Test Your Nix Code
  29. Introducing the Scalable Build Systems Team
  30. Introduction to NixOS specialisations
  31. Better soft k-means clustering with Chainsail - multimodality treated right
  32. Announcing Chainsail: a web service for sampling multimodal probability distributions
  33. Our roadmap for Nix
  34. Profiling non-CPU time in Haskell
  35. A dialogue with Liquid Haskell
  36. Nix – taming Unix with functional programming
  37. Introducing Pirouette 2: formal methods for smart contracts
  38. Incremental builds for Haskell with Bazel
  39. Smooth, non-invasive Haskell Stack and Nix shell integration
  40. Reproducible probabilistic programming environments
  41. Comparing strict and lazy
  42. Existential optics
  43. Union and intersection contracts are hard, actually
  44. Announcing WebAuthn
  45. Getting Things Merged
  46. How I stopped worrying and learned to run wasm and native hybrid code
  47. Our first audit of Minswap and the aftermath
  48. Porting libffi to pure WebAssembly
  49. First release of Nickel
  50. Improving Criterion.rs
  51. Named Routes in Servant
  52. Type-checking plugins, Part III: writing a type-checking plugin
  53. Ormolu: the challenge of formatting operator chains
  54. Trustix - Consensus and voting
  55. A Case Study on Correctness and Safety Testing of Stateful Systems
  56. Why Liquid Haskell matters
  57. Trustix - Good things come in trees
  58. Scoped Effect Resources for Polysemy

2021 41

  1. Nix 2.4 and 2.5
  2. 21.11 Zero Hydra Failures Moscow Hackathon: Report and Suggestions
  3. Type-checking plugins, Part II: GHC's constraint solver
  4. Implementing a content-addressed Nix
  5. The Varieties of the Haskelling Experience
  6. Safe Sparkle: a resource-safe interface with linear types
  7. A Haskell memory leak in way too much detail with Cachegrind
  8. Hacking on Ormolu: An internship report
  9. Type-checking plugins, Part I: Why write a type-checking plugin?
  10. Denotational Homomorphic Testing
  11. A higher-order integrator for Hamiltonian Monte Carlo
  12. Functional data pipelines with funflow2
  13. Building a Go project using Bazel
  14. Daily ICFP: Day 5
  15. Daily ICFP: Day 4
  16. Daily ICFP: Day 3
  17. Daily ICFP: Day 2
  18. Daily ICFP: Day 1
  19. Daily ICFP: Day 0
  20. Convert Cabal-based projects to Bazel automatically
  21. Integrated shrinking in QCheck
  22. Searching for COVID-19 treatments using metabolic networks
  23. Exploring linear Traversable using generics
  24. Building OCaml Projects with Bazel
  25. Deconstructing classes
  26. 2021-06-15-asciidoc-haskell-pandoc
  27. Simulating Tenderbake
  28. Ormolu internship
  29. Arrows, through a different lens
  30. Ad-hoc interpreters with capability
  31. Incubating the Haskell Foundation
  32. How to build hybrid Haskell and Java programs
  33. Types à la carte in Nickel
  34. Announcing Gomod2nix
  35. Battle-tested monadic OCaml: Tezos
  36. Derivation outputs in a content-addressed world
  37. linear-base makes writing Linear Haskell easy and fun
  38. Integrating refinement and dependent types: a fellowship report
  39. Intern opening to improve GHC performance
  40. Programming with contracts in Nickel
  41. Haskell dark arts, part I: importing hidden values

2020 41

  1. Trustix: Distributed trust and reproducibility tracking for binary caches
  2. The Shrinks Applicative
  3. A tale of Template Haskell and cross compilation
  4. Self-references in a content-addressed Nix
  5. Pure destination-passing style in Linear Haskell
  6. Introduction to Markov chain Monte Carlo (MCMC) Sampling, Part 4: Replica Exchange
  7. Nickel: better configuration for less
  8. Edge computing with servant on Cloudflare
  9. Making GHCIDE smarter and faster: a fellowship summary
  10. Fully statically linked Haskell binaries with Bazel
  11. Announcing Lagoon
  12. Implicit Dependencies in Build Systems
  13. Towards a content-addressed model for Nix
  14. How Nix grew a marketing team
  15. Developing Python with Poetry & Poetry2nix: Reproducible flexible Python environments
  16. Introduction to Markov chain Monte Carlo (MCMC) Sampling, Part 3: Hamiltonian Monte Carlo
  17. Nix Flakes, Part 3: Managing NixOS systems
  18. Fall 2020 Fellowships: Funding for Open Source Contributors
  19. Qualified do: rebind your do-notation the right way
  20. Setting up Buildkite for Nix-based projects using Terraform and GCP
  21. Splittable pseudo-random number generators in Haskell: random v1.1 and v1.2
  22. Nix Flakes, Part 2: Evaluation caching
  23. Linear types are merged in GHC
  24. Long-term reproducibility with Nix and Software Heritage
  25. Calling to the JVM from Haskell: Some benchmarks
  26. Tweag Open Source Fellows
  27. Nix Flakes, Part 1: An introduction and tutorial
  28. A taste of Bazel: build a library, a service and hspec tests
  29. Deriving Isomorphically
  30. The three kinds of Haskell exceptions and how to use them
  31. Setting up a shared build cache using Bazel
  32. Eager vs. Lazy Instantiation: Making an Informed Decision
  33. Inferred or Specified Types? Your Choice!
  34. Code is Engineering, Types are Science
  35. Probabilistic Programming with monad‑bayes, Part 3: A Bayesian Neural Network
  36. On linear types and exceptions
  37. Tweag Fellowships: Funding for Open Source Contributors
  38. Safe memory management in inline-java using linear types
  39. Locating Performance Bottlenecks in Large Haskell codebases
  40. A Tale of Two Functors or: How I learned to Stop Worrying and Love Data and Control
  41. Introduction to Markov chain Monte Carlo (MCMC) Sampling, Part 2: Gibbs Sampling

2019 28

  1. Haskell art in your browser with Asterius
  2. How to make your papers run: Executable formal semantics for your language
  3. Untrusted CI: Using Nix to get automatic trusted caching of untrusted builds
  4. Probabilistic Programming with monad‑bayes, Part 2: Linear Regression
  5. Here You See the Small Porcupine Perched in Its Tree, Preparing and Crunching Some Data with Me
  6. Markov chain Monte Carlo (MCMC) Sampling, Part 1: The Basics
  7. Ormolu: Announcing First Release
  8. Bazel, Cabal, Stack: Why choose when you can have them all?
  9. Bazel's Persistent Worker Mode for GHC: An Industrial Internship
  10. Probabilistic Programming with monad‑bayes, Part 1: First Steps
  11. War Stories of Asterius: Numerics & Debugging
  12. Why Haskell is important
  13. Code Line Patterns: Creating maps of Stackage and PyPi
  14. Revelations from repetition: Source code headers in Haskell and Python
  15. CPP considered harmful
  16. Ormolu: Format Haskell code like never before
  17. inline-js: seamless JavaScript/Haskell interop
  18. The Sneakernet: Towards A Much Faster Internet
  19. Securely storing secrets in Terraform with terraform-provider-secret
  20. Introducing lorri, your project's nix-env
  21. Capability is about free monads. It's a bird… It's a plane… It's a free monad!
  22. Tweag Internship Programme 2019
  23. Configuring and testing Kubernetes clusters with KubeNix and kind
  24. JupyterWith: Declarative, Reproducible Notebook Environments
  25. Clodl: build, copy, and run
  26. The types got you
  27. Mapping a Universe of Open Source Software
  28. Towards Interactive Data Science in Haskell: Haskell in JupyterLab

2018 15

  1. Asterius GHC WebAssembly backend reaches TodoMVC
  2. DIY benchmark history with Criterion and Shiny
  3. capability: the ReaderT pattern without the boilerplate
  4. Haskell WebAssembly calling JavaScript and back again
  5. Funflow Example: emulating Make
  6. Streaming with linear types
  7. Fibonacci compiles end-to-end — Haskell to WebAssembly via GHC
  8. Funflow: typed resumable workflows
  9. Stackage HEAD is now live!
  10. We're hiring! Software engineers
  11. Nix + Bazel = fully reproducible, incremental builds
  12. Implementing a safer sort with linear types
  13. Build large polyglot projects with Bazel... now with Haskell support
  14. Tweag Internship Programme
  15. Free monads for cheap interpreters

2017 24

  1. All about reflection: a tutorial
  2. Making two garbage collectors be good neighbours (using linear types)
  3. Parallelising your array code
  4. Nix on the Windows Subsystem for Linux
  5. The Exodus to Streamgard, an epic poem
  6. Using Stackage for GHC regression testing
  7. Announcing the GHC DevOps Group
  8. Array fusion with vector
  9. How to compose streaming programs
  10. Immutability and unboxing in array programming
  11. GHC compiler plugins in the wild: typing Java
  12. Java from Haskell: a tutorial
  13. Tracking performance over the entire software lifecycle
  14. Enter the matrix, Haskell style
  15. Compact normal forms + linear types = efficient network communication
  16. Diversity through inline code
  17. Array programming in Haskell
  18. Encode state transitions in types using linear types
  19. I am a functional programming evangelist
  20. Streaming programs without laziness: a short primer
  21. R and Haskell: best of both worlds with HaskellR
  22. Typing Nix
  23. We're hiring! Technical evangelist
  24. Linear types make performance more predictable

2016 3

  1. A new ecosystem for Haskell: the JVM
  2. Haskell compute PaaS with sparkle
  3. Haskell meets large scale distributed analytics

2015 2

  1. Stack + Nix = portable reproducible builds
  2. Programming R at native speed using Haskell