The Glasgow Haskell Compiler (GHC) is a state-of-the-art compiler and interactive environment for the functional language Haskell.

The Glasgow Haskell Compiler (GHC) is a state-of-the-art compiler and interactive environment for the functional language Haskell.

The Neko programming language is a high-level dynamically typed programming language. It can be used as an embedded scripting language. It has been designed to provide a common runtime for several different languages. You can easily extend the language with C libraries. You can also write generators from your own language to Neko and then use the Neko Runtime to compile, run, and access existing libraries.

Neko has a compiler and a virtual machine. The Virtual Machine is both very lightweight and well optimized, so it can run very quickly. The VM can be easily embedded into any application and your libraries can be accessed using the C foreign function interface.

You can use the compiler as standalone command line executable separate from the VM, or as a Neko library to perform compile-and-run functions for interactive languages.

Haxe is a toolkit based on a modern, high level, static-typed programming language, a cross-compiler, a complete cross-platform standard library and ways to access each platform's native capabilities. This package includes the compiler and library manager.

HashLink (HL) is a virtual machine for the Haxe language. It can run bytecode produced by the Haxe compiler, or converted to C by HL. The HashLink runtime includes the following features:

• Fully compatible with the Haxe specification

• Support file I/O, regular expressions, network, etc.

• Unicode strings by default

• Mark-and-not-sweep Garbage Collector

• x86 and x86-64 HL/C compilation

• x86 and x86-64 HL/JIT compilation

While the standard HL runtime provides support for Haxe standard library, HashLink also provides several libraries that can optionally be used to build HL-specific applications. This includes the FMT library for compression and image support and SDL for mouse, keyboard, and game controller support, OpenGL, and more.

This package provides a dev.cpio file usable as a base for heads' initrd.

Musl-cross toolchain: binutils, gcc 5 and musl.

bvi is a display-oriented editor for binary files, based on the vi text editor.

This package provides tool, language and decoders for working with binary data, aiming to be jq, hexdump, dd and gdb for files combined into one.

This package provides a C-like domain-specific language used for specifying patterns in the ImHex Hex Editor.

ImHex is a hex editor with many advanced features that can often only be found in paid applications. Such features are a completely custom binary template and pattern language to decode and highlight structures in the data, a graphical node-based data processor to pre-process values before they're displayed, a disassembler, diffing support, bookmarks and much much more.

Dhex is hex editor which includes a diff mode, which can be used to easily and conveniently compare two binary files. It is based on Ncurses and is themeable.

hexedit shows a file both in ASCII and in hexadecimal. The file can be a device as the file is read a piece at a time. You can modify the file and search through it.

NATS is a simple, secure and performant communications system for digital systems, services and devices. NATS is part of the Cloud Native Computing Foundation (CNCF). NATS has over 40 client language implementations, and its server can run on-premise, in the cloud, at the edge, and even on a Raspberry Pi. NATS can secure and simplify design and operation of modern distributed systems.

RabbitMQ is a messaging and streaming broker that supports multiple messaging protocols, including AMQP 1.0 and MQTT 5.0. It offers features such as message routing, filtering, streaming, federation, and clustering. It is designed for reliability and flexibility.

cowsql (/ˈkaʊ,siːkwəl/ listen) is a C library that implements an embeddable and replicated SQL database engine with high availability and automatic failover.

cowsql extends SQLite with a network protocol that can connect together various instances of your application and have them act as a highly-available cluster, with no dependency on external databases.

NSQ is a realtime distributed messaging platform designed to operate at scale, handling billions of messages per day.

Key features:

• support distributed topologies without SPOF

• scale horizontally (no brokers, seamlessly add more nodes to the cluster)

• low-latency push based message delivery (performance)

• combine load-balanced and multicast style message routing

• excel at both streaming (high-throughput) and job oriented (low-throughput) workloads

• primarily in-memory (beyond a high-water mark messages are transparently kept on disk)

• runtime discovery service for consumers to find producers (nsqlookupd)

• transport layer security (TLS)

• data format agnostic

• few dependencies (easy to deploy) and a sane, bounded, default configuration

• simple TCP protocol supporting client libraries in any language

• HTTP interface for stats, admin actions, and producers (no client library needed to publish)

• integrate with StatsD for realtime instrumentation

• robust cluster administration interface (nsqadmin)

HAProxy offers HA, load balancing, and proxying for TCP and HTTP-based applications. It is particularly suited to Web sites crawling under very high loads while needing persistence or Layer 7 processing. Supporting tens of thousands of connections is clearly realistic with today's hardware.

The Corosync Cluster Engine is a Group Communication System with additional features for implementing high availability within applications. The project provides four C Application Programming Interface features:

• A closed process group communication model with extended virtual synchrony guarantees for creating replicated state machines.

• A simple availability manager that restarts the application process when it has failed.

• A configuration and statistics in-memory database that provide the ability to set, retrieve, and receive change notifications of information.

• A quorum system that notifies applications when quorum is achieved or lost.

Pacemaker is a high-availability cluster resource manager.

It achieves maximum availability for your cluster services (a.k.a. resources) by detecting and recovering from node- and resource-level failures by making use of the messaging and membership capabilities provided by Corosync.

It can do this for clusters of practically any size and comes with a powerful dependency model that allows the administrator to accurately express the relationships (both ordering and location) between the cluster resources.

Virtually anything that can be scripted can be managed as part of a Pacemaker cluster.

Libqb is a library with the primary purpose of providing high-performance, reusable features for client-server architecture, such as logging, tracing, IPC and polling. Libqb is not intended to be an all-encompassing library, but instead provide focused APIs that are highly tuned for maximum performance for client-server applications.

This package implements a Raft algorithm logic (no I/O and no system calls). On top of that, various drivers are provided that implement actual network communication and persistent data storage.

The core part of the library is designed to work well with asynchronous or non-blocking I/O engines (such as libuv and io_uring), although it can be used in threaded or blocking contexts as well.

Kronosnet, often referred to as knet, is a network abstraction layer designed for High Availability use cases, where redundancy, security, fault tolerance and fast fail-over are the core requirements of your application.

Kronosnet is the new underlying network protocol for Linux HA components (Corosync), that features ability to use multiple links between nodes, active/active and active/passive link failover policies, automatic link recovery, FIPS compliant encryption (nss and/or openssl), automatic PMTUd and in general better performances compared to the old network protocol.

Hugs 98 is an interpreter and programming environment for developing Haskell programs. It provides an almost complete implementation of Haskell 98, which includes expression and pattern syntax, primitives for monadic I/O, with support for simple interactive programs, handle-based I/O, and exception handling. Hugs has a nearly complete implementation of the Haskell module system and supports a number of advanced extensions.