Free peer to peer programs software for linux

Solving Constraint Integer Programs is a framework for constraint integer programming. For solving Integer Programs and Constraint Programs, a very similar technique is used: the problem is successively divided into smaller subproblems (branching) that are solved recursively.
On the other hand, Integer Programming and Constraint Programming have different strengths: Integer Programming uses LP relaxations and cutting planes to provide strong dual bounds, while Constraint Programming can handle arbitrary (non-linear) constraints and uses propagation to tighten the variables domains.
SCIP is a framework for Constraint Integer Programming oriented towards the needs of Mathematical Programming experts who want to have total control of the solution process and access detailed information down to the guts of the solver. SCIP can also be used as pure MIP solver or as framework for branch-cut-and-price.
Main features:
- It is a framework for branching, cutting, pricing, and propagation.
- It is highly flexible through many possible user plugins:
- constraint handlers to implement arbitrary constraints,
- variable pricers to dynamically create problem variables,
- domain propagators to apply constraint independent propagations on the variables domains,
- cut separators to apply cutting planes on the LP relaxation,
- relaxators to provide relaxations and dual bounds in addition to the LP relaxation,
- primal heuristics to search for feasible solutions with specific support for probing and diving,
- node selectors to guide the search,
- branching rules to split the problem into subproblems,
- presolvers to simplify the solved problem,
- file readers to parse different input file formats,
- event handlers to be informed on specific events, e.g., when a node was solved, a specific variable changed its bounds, or a new primal solution was found,
- display handlers to create additional columns in the solvers output.
- dialog handlers to extend the included command shell.
- Every existing unit is implemented as a plugin, leading to an interface flexible enough to meet the needs of most additional user extensions.
- A dynamic cut pool management is included.
- The user may mix preprocessed and active problem variables in expressions: they are automatically transformed to corresponding active problem variables.
- Arbitrarily many children per node can be created, and the different children can be arbitrarily defined.
- It has an open LP solver support (currently supporting ILOG CPLEX, Dash XPress-MP, SoPlex, and CLP.
- The LP relaxation need not to be solved at every single node (it can even be turned off completely, mimicing a pure constraint solver).
- Additional relaxations (e.g., semidefinite relaxations or Lagrangian relaxations) can be included, working in parallel or interleaved.
- Conflict analysis can be applied to learn from infeasible subproblems.
- Dynamic memory management reduces the number of operation system calls with automatic memory leakage detection in debug mode.
Enhancements:
- The new heuristics "RENS", "mutation", "veclendiving", and "intshifting", were included.
- The existing ones were improved.
- Presolving and c-MIR cut generation were improved.
- A few bugs were fixed.

POE (Perl Object Environment) parcels out execution time among one or more tasks, called sessions. Sessions multitask through cooperation (at least until Perls threads become mainstream). That is, each session returns execution to POE as quickly as possible so it can parcel out time to the next.
POE includes a high-level component architecture. Components are modular, reusable pieces of programs. They perform common, often tedious tasks so programmers can work on more interesting things.
Several POE components have been written to handle client, server, and peer networking tasks. Because of them, POE has become a convenient and quick way to write multitasking network applications.
Anyone can write and publish POE components. The CPAN contains a [steadily growing list] of them. The POE Components List includes ones that havent been uploaded to the CPAN yet.
POE provides medium- and low-level concurrency functions. Components use them to perform their tasks. The functions are also available to programmers who prefer to avoid the overhead of components at the expense of writing more code. Components and custom sessions coexist because they all use the same basic functions.
POE supports graphical toolkits such as Tk and Gtk. It is the only Perl programming framework that does this. It also supports Curses, HTTP, and other user interfaces. POE programs can present multiple user interfaces at once.
Enhancements:
- A number of stability and performance fixes were done, including making the tests less prone to race conditions, improving the installation process, eliminating known resource leaks, and reducing CPU use when combined with Tk.

SirBot Project provides an easy way to build, program, control, and monitor amateur robots. Programming a bot is done writing a Python class. A declaration protocol syntax is used to define what can be done (primitive/complex actions). Using a Python CLI, the robot can be interactively controlled and dynamically programmed.
While the bot is performing several actions, every piece of information is able to produce events, thanks to the event declaration syntax. Events can also be created from other events (cascading events), conditionnaly triggered under specific conditions (pre-condition), and activate user-defined actions (post-conditions) according to a particular event state. The library provides detailed instructions to build electronic boards (PIC-based) and connect them to build a robot.
Easy way to build the bot
The SirBot Project provides every instructions to build a bot. A main board provides the basic features such as communication capabilities and implementation of a defined protocol. Several module can be plugged into this main board to provide extra feature such as, currently, a servo controller, IR distance ranger. Have a look on the SirBot Module Library to see current available modules/features. Also have a look at the SirBot Labs, where you can find examples of robots built with SirBot.
Easy way to program the bot
SirBot is python-based, your robot is just an object Protocol. Thanks to the power of python and its librairies, performing complex actions is (almost) trivial. No C++ here... just a protocol declaration syntax, easy to use.
Easy way to control the bot
Because SirBot is python-based, you can access your bot with a python CLI, such as ipython, and interactively control and program your bot. Soon, a graphical interface will allow to visually control your robot.
Easy way to monitor the bots actions
While the bot performs several actions, every piece of information is able to produce events, thanks to the event declaration syntax. Events can also be created from other events (cascading events), conditionnaly triggered under specific conditions (pre-condition), and activate user-defined actions (post-conditions) according to a particular event state.
Enhancements:
- Either the robot or PC can initiate the communication (Master/Slave vs. Peer-to-Peer mode).
- Recurrent tasks can be defined as background jobs (polling the bot, etc.).
- There is a dedicated Web site, documentation, and many fixes in Jal libraries.

OpenRPG project is suite of RPG utilities for online and tabletop gaming.
More accurately described, OpenRPG is a role-playing game shell. In its basic form, OpenRPG is a peer-to-peer chat program with very advanced die rolling capabilities, a web based miniature map (think virtual table top), and a data organizer (game tree).
However, OpenRPG is highly extendable and customizable. OpenRPG is designed in a way to facilitate the development of add-ons or extension modules (called applets) that can add to its functionality.
Add-ons are created on top of the gaming shell using resources provided by the OpenRPG core. Currently, OpenRPG contains a collection of generic and system specific add-ons. OpenRPG also supports form based character sheet.
Main features:
Miniature Map: Simulate combat with a layered, web base, miniature map. Load any image off the web! Map features include: hex or square adjustable overlay grid, background images, z-order, facing, labels, free hand drawing, tape measure, and more.
Game Tree: A highly customizable data organizer that allows for the creating of custom made characters sheets and GM aids. A plug in architecture that allows for openrpg add-ons!
Chat: A full featured chat system that allows embed HTML. Embed color, tables, images, and links!
Die Engine: A full feature die engine that contains many of the common die roll options and a plug in architecture that allows for the development of game specific rollers.
Game Servers: Run your own dedicated game server.

Peers is a distributed programming toolkit designed for building peer-to-peer systems. The toolkit is a hybrid language project which offers low level primitives for managing concurrency and communication.
Using these primitives, complex P2P protocols and complete systems can be designed and implemented in Python, while maintaining high performance for critical operations.
Enhancements:
- [python] Fixed the exceptions. Now peers exceptions have native python exception representation
- [python] Fixes in the peers-python reference count binding for python-land pointers entering the peers kernel
- [python] Fixed bind/unbind for local objects. bind/unbind are now instance methods that can be normally called.
- [python] Eliminated copying in the python representation of x_data
- [python] Added marshalling support
- [python] Fixed old-style class support in multi-methods
- [rpcc] Eliminated conditions of conflicting type regisration in generated Boost bindings
- [rpcc] Makefile/rule file generation scripts
- [rpcc] python-land marshalling support for XX structs
- [cxx] Added support for GNU libg++ atomic reference counts
- [cxx] Removed the immediate dispatch of remote call returns in the event loop, as it can violate logical ordering if back-calls are performed in the same context.

edonkey plus is a free program peer to peer (P2P) for the peer to peer network Edonkey 2000, Overnet etc.
Basic aMule Tips
- NEVER run aMule as root.
- If you are behind a firewall or router, be sure that the ports have been opened. The default ports are 4662 (TCP). 4665 (UDP) and 4672 (UDP). If these are blocked, you will receive a "LowID" which results in fewer available sources for the files you are downloading.
- Obtain an appropriate server.met: e.g., if you are a dialup, using a large server list is not appropiate.
- Set your temp and shared directories in Preferences->Directories
- To recursively select a certain directory, right-click over it.
- You should *NOT* share
- Your temp download directory!
- Your /etc directory
- Probably not your /var, /lib, /boot, or /usr directory
- Certainly make sure that any really confidential files (password files, private SSH keys, credit card numbers :) are *not* shared. So generally do not share your entire home directory, although you might want to share some files or directories in it.
- Remember that you get certain download priveledges with those clients (aMule, eMule, etc users) to whom you upload files, in the form of reduced queue waits.
- Please note that compilation with optimizations is supported. However, if you pull a Gentoo, we will probably just tell you to recompile aMule and/or your system with sane compiler-flags before we will attempt to address the problem.