Crystal is a simple kwin window decoration, with a simple design,
but with (pseudo) transparent titlebar, buttons and borders.
This is a GTK+ 2.x engine based on Bluecurve. It features a modern look
without sacrificing (much) speed.
A Haskell binding for the OpenGL Utility Toolkit, a window system
independent toolkit for writing OpenGL programs.
This package contains luit, a filter than can be run between an arbitrary
application and a UTF-8 terminal emulator.
A tabbed, vte- (GTK+) based terminal emulator providing advanced
features such as multiple tabs with a small footprint.
NoteCase is a hierarchical text notes manager (a.k.a. outliner). It helps you
organize your everyday text notes into a single document with individual notes
placed into a tree-like structure. To ensure your privacy an encrypted document
format is supported along with a standard unencrypted one.
Hachoir is the french name for a mincer: a tool used by butchers to cut
meat. Hachoir is also a tool written for hackers to cut file or any
binary stream. A file is split in a tree of fields where the smallest
field can be just a bit. There are various field types: integer, string,
bits, padding, sub file, etc.
A vault is a persistent store for values of arbitrary types. It's like
having first-class access to the storage space behind IORefs. The data
structure is analogous to a bank vault, where you can access different
bank boxes with different keys; hence the name. Also provided is a
locker type, representing a store for a single element.
A library for handling page faults in user mode. A page fault occurs
when a program tries to access to a region of memory that is currently
not available. Catching and handling a page fault is a useful
technique for implementing:
* pageable virtual memory,
* memory-mapped access to persistent databases,
* generational garbage collectors,
* stack overflow handlers,
* distributed shared memory,
AnyEvent::Task is a pre-fork-on-demand server (AnyEvent::Task::Server) combined
with a persistent worker-pooled client (AnyEvent::Task::Client).
In a nutshell, a synchronous worker process is forked off by a server whenever
a client asks for one. The client keeps as many of these workers around as it
wants and delegates tasks to them asynchronously.