Free posix threads software for linux

True3D*Shell is an open source 3D desktop environment that allows users to experience 3D browsing in a virtual reality universe where information is organized in bubbles connected by pipes. True3D*Shell is based on POSIX, Win32, FreeGLUT, OpenGL and MQ4CPP, and runs on IA32 and IA64 SMP platforms.
A user can browse local and remote filesystems and download and run selected files. It includes a robot mode that allows you to browse automatically.
Main features:
- Shell : provides access to the kernel services
- Desktop environment : offers a graphical user interface (GUI) solution to operate a computer
- Avatar : provides a fantastic representations of a persons self with witch user can explore the virtual universe.
- Virtual Reality : users can interact with a virtual environment either through the use of standard input devices such as a keyboard and mouse, or through multimodal devices.
- MVC paradigm : is a software architecture that separates an applications data model, user interface, and control logic into three distinct components.
- Multithreading : Threads are a way for a program to split itself into two or more simultaneously running tasks. Multiple threads can be executed in parallel on many computer systems.
- Grid computing : provides the ability to perform higher throughput computing by taking advantage of many networked computers to model a virtual computer architecture that is able to distribute process execution across a parallel infrastructure.
- MOM paradigms : Message Oriented Middleware is a category of inter-application communication software that relies on asynchronous message passing as opposed to a request/response metaphor.

posh is a stripped-down version of pdksh with several improvements that aims for compliance with Debians /bin/sh policy, and few extra features.

Currently, Debians policy is to adhere to POSIX with the exception of supporting echo -n, so posh strives toward compliance with SUSv3 (with the exception of echo -n).

Linux Bandwidth Monitor (bwmon) is yet another utility that measures bandwidth utiliazation per interface basis. It is coded in C and takes advantage of POSIX thread and curses library. It runs only on Linux systems since the utility reads /proc/net/dev and /proc/uptime.

The utility reads /proc/net/dev and /proc/uptime files in order to print out bandwidth usage at user selected intervals, maximum bandwidth usage since initialization of the utility and average bandwidth usage since the last reboot. This is done based on network interface.

Tested on Linux 2.2.x, 2.4.x and 2.5.x, SuSE and RedHat distributions.
To compile, simply say
$ make
To install, say (optional)
# make install
Or copy bwmon binary where ever you want.

Bigloo is a Scheme implementation devoted to one goal: enabling Scheme based programming style where C(++) is usually required.
Bigloo attempts to make Scheme practical by offering features usually presented by traditional programming languages but not offered by Scheme and functional programming.
Bigloo compiles Scheme modules. bigloo delivers small and fast stand alone binary executables. Bigloo enables full connections between Scheme and C programs, between Scheme and Java programs, and between Scheme and C# programs.
Main features:
- Module support
- An extended Java interface
- An extended C interface
- An object oriented layer
- Threads
- Simple exception
- Practical IOs
- Posix support
- Library support
- An explicit type system and compile time type mismatch detections
- Dsssl support
- Unicode support
The current version has been compiled and tested on:
- x86-linux (Debian 3.0, Mandrake 8.1, Sun JDK 1.4.1)
- x86-win32 (Windows 2000, XP)
- x86-FreeBSD (4.0)
- x86-NetBSD (1.6)
- x86-MinGW ()
- PowerPC G4 (MacOS X xnu-201.5)
- PowerPC G3 (Gentoo Linux)
- SPARC (Solaris 2.6 and 2.8, Sun JDK 1.3, Linux (Debian))
- Compaq Alpha (Digital Unix 4.0f aka True64, JDK 1.3)
- Compaq Alpha (Linux 2.2 (Debian))
- Arm (Linux (Debian))
- IA64 (Linux (Debian))
- IBM P660 (AIX RS-6000 4.3.3)
Even if not tested, it should run correctly on:
- SGI (IP32)
- Intel (NeXTStep)
- IBM RS-6000 (AIX)
- SGI (IP20 and IP22)
- MAC PPC (2.2.15pre20)

The Multithread Network Port Scanner uses 50 POSIX threads to scan hosts. In 1 minute Up to 1000 ports can be scanned by it .
Conntrack-Viewer is a perl script to view the masquerading connections with iptables, it uses /proc/net/ip_conntrack
With ipchains, it was extremely easy to view the masquerading connections, netstat -M or netstat --masquerade gave you the result right away.
But since iptables, if you try this you will get: "netstat: no support for `ip_masquerade on this system.". With iptables, the informations regarding the masquerading connections are accesible via /proc/net/ip_conntrack wich is extremely hard to read
This is why Conntrack-Viewer is so helpfull, it make those criptic results a lot more legible.
Enhancements:
- changed the service detection to use distant AND source port

MTasker is a two-file C++ library designed to support very simple cooperative multitasking. MTasker can facilitate writing code that would ordinarily require a state machine, for which the author does not consider himself smart enough.
This class does not perform any magic it only makes calls to makecontext() and swapcontext(). Getting the details right however is complicated and MTasker does that for you.
If preemptive multitasking or more advanced concepts such as semaphores, locks or mutexes are required, the use of POSIX threads is advised.
MTasker is designed to offer the performance of statemachines while maintaining simple thread semantics. It is not a replacement for a full threading system.
Enhancements:
- A theoretically damaging bug was fixed involving delete[] vs delete, spotted by Valgrind.
- There is tentative Solaris support, not heavily tested.
- Furthermore, a new method called numProcesses() was added so the kernel can query how many processes are running, and perhaps acting on that.

The Prex project is an open source initiative to provide a portable real-time operating system for embedded systems.
This project originally started to make a royalty-free OS for mobile phones and PDA in order to spread open source movement to such proprietary OS field. And now, the project target has been shifted to the wider area of real-time and embedded systems.
Prex is designed specifically for small memory footprint platforms. It is written in C language based on traditional micro-kernel architecture. The Prex kernel provides only fundamental features for task, thread, memory, ipc, exception, and synchronization.
The other basic OS functions, process, file system, application loading, and networking, are provided by the user mode servers. In addition, Prex provides a POSIX emulation layer in order to reuse the existing applications.
Prex is an open source royalty-free OS for mobile phones and PDA.
This design allows system to perform both of the native real-time task and the generic *NIX process simultaneously without degrading the real-time performance. Furthermore, it helps the platform designer to construct OS by choosing suitable server tasks for their target requisition.
Prex is royalty-free software released under BSD License
Main features:
- Task and thread control: preemptive priority scheduling with 256 priority levels
- Memory management: virtual address mapping, shared memory, memory protection, with MMU
- IPC: synchronous message passing among threads, object name space in kernel
- Exception: framework for POSIX signal emulation
- Synchronization: semaphores, condition variables, and mutexes with priority inheritance
- Timers: sleep timers, alarm timers
- Interrupt: nested interrupt service routines, and prioritized interrupt service threads
- Device I/O: minimum synchronous I/O interface
- Real-time: low interrupt latency, high resolution timers, periodic timers, and scheduling quantum control
- Cross platform portability: well defined architecture dependent layer and driver-kernel interface
- Modular design: OS servers and BSP module separated from kernel
- Small memory footprint: kernel size < 25k bytes
- Low power consumption: control of processor idle state, support of DVS (Dynamic Voltage Scaling)
- Disk-less: on-core kernel, no memory page swapping
- Instantly available: minimal OS boot time, system suspend/resume, kernel warm restart
- File systems: VFS framework, RAM/FAT/Flash file systems optimized for embedded systems
- Networking: TCP/IP stack, BSD socket interface
- POSIX emulation: signal, process, file I/O, real-time extensions, pthread, etc
- Debug: event logging, GDB remote debug
Enhancements:
- A file system server was added. arfs, devfs, and ramfs are supported with this version.

Tachyon is a multiprocessor ray tracing system which can be used as a standalone program, or as a library within other programs. The project is written in C, uses POSIX Threads and/or MPI for using multiple processors, and can also run on uniprocessor machines.
It supports almost any Unix-like system, Windows, and BeOS, as well as several embedded systems and high end supercomputers. Tachyon is easy to port to new machines, and is very fast, using a number of ray tracing acceleration schemes to achieve good performance on very complex scenes. (It easily handles scenes containing more than 100,000 objects, and does so without taking a long time to render)
Enhancements:
- Memory usage for highly complex scenes has been reduced.
- User-defined clipping planes and improved texture management have been added. Compilation targets have been updated.
- There are minor code cleanups.