How to set up vulkan Haskell bindings on Windows with Cabal?

Follow the multi-step guide in the README: install the Vulkan SDK, clone with submodules, add library paths to cabal.project.local, and ensure system DLLs are available, which can be error-prone for newcomers.

vulkan vs vulkan-api for Haskell: which is better?

vulkan offers high-level, idiomatic bindings with automatic memory management and type safety, while vulkan-api uses C-like ByteArray# for performance; choose based on preference for Haskell idioms versus low-level control.

Can I use Haskell callbacks for Vulkan debug messages with this library?

Yes, but unsafe FFI calls are default, so you must enable the safe-foreign-calls flag or use Safe-suffixed functions to allow Haskell callbacks without blocking garbage collection, as warned in the README.

Are all Vulkan 1.3 features supported in these bindings?

Core Vulkan 1.0 to 1.3 functions are included, but check the disabled extensions list for omissions like video support; the README's 'Current Status' section details this.

How to handle arrays and optional parameters in vulkan Haskell?

The library uses Vector for arrays and Maybe for optional pointers, automatically setting length fields, but requires equal-length vectors for paired arrays or else throws exceptions, as per the marshaling rules.

What's the performance impact of using Haskell bindings for Vulkan?

FFI calls are marked unsafe by default to reduce overhead, but this trade-off means garbage collector pauses during Vulkan operations; safe versions exist for blocking calls, adding complexity.

Open-Awesome

vulkan

BSD-3-ClauseHaskellutils-v0.5.11.0

High-level, idiomatic Haskell bindings for the Vulkan graphics API, reducing verbosity while retaining full functionality.

Visit Website GitHub

164 stars35 forks0 contributors

What is vulkan?

Vulkan is a Haskell library that provides high-level bindings to the Vulkan graphics API, offering an idiomatic Haskell interface that reduces the verbosity and boilerplate of the C API. It automates low-level tasks like function pointer retrieval and memory management while retaining full access to Vulkan's features, making it easier to write graphics and compute applications in Haskell.

Target Audience

Haskell developers working on graphics-intensive applications, game engines, or GPU compute projects who want to leverage Vulkan's performance without dealing with C-level complexity.

Value Proposition

Developers choose these bindings for their type-safe, idiomatic Haskell design that eliminates Vulkan's C API verbosity, provides automatic error handling, and ensures memory safety through bracketed commands, all while maintaining full compatibility with Vulkan's specification.

Overview

Haskell bindings for Vulkan

Use Cases

Best For

Writing high-performance graphics applications in Haskell
Building game engines with Vulkan backend support
Developing GPU compute programs using Vulkan's compute pipelines
Creating cross-platform graphics tools with Vulkan
Learning Vulkan in a type-safe, functional programming environment
Prototyping graphics features with automatic resource management

Not Ideal For

Teams deeply embedded in C++ Vulkan ecosystems seeking drop-in compatibility
Projects requiring immediate access to Vulkan's video extensions (e.g., for real-time encoding/decoding)
Environments restricted to 32-bit systems or older GHC versions (<8.6)
Developers wanting a graphics engine with pre-built rendering pipelines and minimal API work

Pros & Cons

Pros

Automatic Function Pointers

Eliminates manual vkGetInstanceProcAddr calls, reducing setup boilerplate and errors as explicitly mentioned in the README's 'Things to know' section.

Type-Safe Struct Chains

Uses Haskell's type system to safely represent Vulkan's pNext chains with GADTs and pattern synonyms, preventing runtime type mismatches.

Memory Safe Bracketing

Provides commands like withInstance and cmdUseRenderPass for automatic resource cleanup, ensuring proper Vulkan resource lifecycle management without manual destroy calls.

Idiomatic Type Conversions

Converts low-level C types (e.g., VkBool32 to Bool, C strings to ByteString) and uses Vector for arrays, making API usage more Haskell-native and readable.

Cons

Missing Video Extensions

Several Vulkan video extensions (e.g., VK_KHR_video_queue) are explicitly disabled in the generator, limiting functionality for multimedia applications as noted in 'Current Status'.

Platform and Version Constraints

The library is 64-bit only and requires GHC 8.6+, excluding older systems and Haskell setups, which restricts portability and adoption.

Complex Build Configuration

Setting up requires specific system packages and detailed steps, especially on Windows with Vulkan SDK and SDL2 dependencies, as outlined in the lengthy 'Building' sections.

Frequently Asked Questions

Related Projects

gfx

[maintenance mode] A low-overhead Vulkan-like GPU API for Rust.

Stars5,396

Forks530

Last commit3 years ago

Silk.NET

The high-speed OpenGL, OpenCL, OpenAL, OpenXR, GLFW, SDL, Vulkan, Assimp, WebGPU, and DirectX bindings library your mother warned you about.

Stars5,139

Forks469

Last commit23 hours ago

Vulkano

Safe and rich Rust wrapper around the Vulkan API

Stars5,121

Forks472

Last commit11 days ago

Vulkan-hpp

Open-Source Vulkan C++ API

Stars3,769

Forks361

Last commit1 day ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub