Free productions software for linux

Foundation project is a real-time multi-player space conquest game.
OpenGL hardware support is recommended. Goals include researching new technology, colonizing distant planets, and fighting intense 3D fleet battles for survival.
Main features:
- colonization
- production of new units, facilities and ships
- research new technology to give you an edge
- space battles
Enhancements:
- more high-level network code (can now transfer fleet info)
- can now build ships
- wont crash if youre not connected to a server but try send a msg
- texture caching system
- fixed check for if a planet is building a certain structure
- slight changes to planetview and fleetview layout
- added more components to fleetview
- moved id to platform class, fleets and planets now both have IDs
- fleet movement mostly complete, still have to deal with deleting fleets
- fixed production bug, need resources now

PRECC eXtended is an infinite-lookahead compiler-compiler for languages with context-dependent grammars. The generated code is ANSI C and ANSI C++; the code will compile and run native under either C or C++.
Specification scripts are extended BNF with inherited and synthetic attributes. Scripts can be compiled in separate modules and linked later. Metalevel production rules are allowed in the scripts. The technology is essentially LL(oo) with optimizations.
Enhancements:
- A "debian" subdirectory has been added in order to allow the building of deb packages from the source archive.

Blockish is a server for the NBD protocol implemented in Java. This allows you to serve up storage as a virtual block device to Linux systems from any system that can run Java. Blockish project is designed to support multiple pluggable backends.

Available backends:

Memory (useful for providing network swap)
File
S3 (Use Amazons S3 service as a block device!)

Blockish is in an early stage of development and should not be used for production work.

mysqlrowcopy is a tool that generates insert statements from result sets. It produces output similar to what might result from running mysqldump on a single SELECT query.

This project helps eliminate some of the tedium of moving data between QA and production MySQL databases.

Build:

To build mysqlrowcopy, you should run:

./configure
make

A mysqlrowcopy and mysqlrowcopy.debug file are created. They have identical functionality, the .debug version simply has debugging symbols built in (for gdb).

Since mysqlrowcopy is probably going to be I/O bound with modest CPU and RAM usage, the only reason to even build a 64-bit version is to work around potential issues in dynamic linking 32-bit binaries against 64-bit libraries.

RECIPES

1. Migrating a MySQL user account reaper from QA server to a production server.

e.g. MySQL database server qa3.example.com to prod1.example.com:

$ mysqlrowcopy -h qa3.example.com
SELECT * FROM db WHERE User = "reaper" mysql db > reaper.sql
$ mysql -h prod1.example.com mysql < reaper.sql

You could of course simply pipe the output of mysqlrowcopy into mysql and skip the intermediate file.

(Dont forget to RELOAD PRIVILEGES afterwards)

2. Keep your test environment up to date. Populate it with production data every 24 hours. You could run this sequence from cron once a day:

$ mysqlrowcopy -h finance-db.example.com
SELECT * FROM stocks WHERE modified > DATE_SUB(NOW(),INTERVAL 24 HOUR)
finance stocks > day-stocks.sql

$ cat day-stocks.sql | mysql -h finance-test.example.com finance

3. Copy data between tables on different servers that have some similar fields.

Youve got common data in table Zip on a production database:

mysql> desc Zip;
+-------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| ZIPCode | varchar(5) | | PRI | | |
| ZIPCodeType | char(1) | YES | | NULL | |
| City | varchar(32) | YES | | NULL | |
| CityType | char(1) | YES | | NULL | |
| State | varchar(32) | YES | | NULL | |
| StateCode | char(3) | YES | | NULL | |
| AreaCode | char(3) | YES | | NULL | |
| Latitude | varchar(12) | YES | | NULL | |
| Longitude | varchar(12) | YES | | NULL | |
+-------------+-------------+------+-----+---------+-------+
9 rows in set (0.00 sec)

And youve got table ZipPosition in a research database:

mysql> desc ZipPosition;
+-------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| ZIPCode | varchar(5) | | | | |
| Latitude | varchar(12) | YES | | NULL | |
| Longitude | varchar(12) | YES | | NULL | |
+-------------+-------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

You want to load data from production Zip into research ZipPosition.

$ mysqlrowcopy -h production SELECT ZIPCode,Latitude,Longitude common ZipPosition > pos.sql
$ cat pos.sql | mysql -h qa research

Note how we specify ZipPosition on the first line to tell mysqlrowcopy what the destination table is going to be.

TitanGS Java project is a multi-player role playing game set in the Star Trek universe.

TitanGS Java is a project to create a game base on the Star Trek universe, that would have no unnecessary rules. The only limits of the game are Star Trek physics (not very limiting).

What the achillies lacks in warp speed it more than makes up for in attack strength. It has some of the strongest phasers in StarFleet. Its array of micro torpedos makes it dangerous to attack from any angle.

The substantial crew complement required to operate, and the prohibitive cost of this ship keeps production fairly low.

Even though there arent many of them, theyre used quite extensively; due mostly to their high success rate.

jPodder is the most complete podcasting program on the planet. Yes we can claim this as, jPodder was one of the first programs to be created for podcasting and has been innovating ever since.
If you own a portable media player like the iPod or you want to listen to fresh content every day on your PC, then read on cause podcasting is what you are looking for.
With jPodder you can subscribe to websites containing audio. jPodder will download the files to your system and transfer these to your favourite media player.
Main features:
Currently supported languages:
- English
- Dutch
General/GUI
- Multi Platform program (Java based).
- Easy installer. (Creates shortcuts on Windows PCs).
- System tray (Minimize jPodder to download in background).
- GUI Menu and popup menus.
- Build-in User manual.
- Multi-Language (0.9 New!)
RSS Feed management
- Add, Remove & Edit feeds.
- Sort feeds by name.(0.9 New!)
- Move feeds up/down
- View detailed Feed information.
- Feeds stored in easy XML format.
- Extensive status bar.
- Drag & Drop Podcasts link (0.9 New!)
Enclosure previewing
- Preview enclosures incl. name, date, size..
- Show enclosure status (Downloaded, In player..)
- Show previous downloads from this feed.
- Highlights partial downloads.
- Highlights previous downloads.
Downloading
- Scheduled downloads
- Multiple simultaneous downloads
- Single enclosure download
- Smart-Download, Downloads latest only.
- Maximum downloads, Limiter to the number of downloads
- Resume partial downloads
- Manual download retry
- Feed Authentication (0.9 New!)
- Proxy Server support (Including authentication)
- build-in BitTorrent. (Including seeding).
Media Player Interface
- Natively supports transfer to iTunes and WMP.
- Player plugin facility. (0.9 New!)
- MIME-Type association to players (0.9 New!)
Podcast Production (0.9 New!)
- Manage production steps
- Auto-create RSS feed
- MP3 Tag editing
- Add enclosures to RSS feed
- Launch recorder
- FTP Transfer production.
- Auto-test RSS feed.
Logging
- Color coded logging.
- BitTorrent logging.

Rats! is an easily extensible parser generator for C-like languages; though currently it only generates parsers in Java. Rats! project has been explicitly designed so that grammars are concise and easily modifiable. To this end, Rats!
- organizes grammars into modules,
- builds on parsing expression grammars instead of context-free grammars and vintegrates lexing with parsing, i.e., is scannerless,
- supports the automatic generation of abstract syntax trees,
- and provides a well-defined interface for extending parsers to recognize context-sensitive languages and formats.
Parsers generated by Rats! memoize intermediate results, which ensures linear time performance in the presence of unlimited lookahead and backtracking. As a result, they are essentially functional (even though they are implemented in an imperative language) and also called "packrat parsers."
Main features:
- Rats! relies on a module system to structure grammars and their extensions. In particular, it relies on modules to group related productions into separate units. Next, module modifications concisely express extensions to other modules and can add, change, or remove individual alternatives in productions. Finally, module parameters are used to compose modules and their extensions with each other.
- Rats! grammars build on parsing expression grammars (PEGs). While PEGs share many constructs with the familiar EBNF notation, a key difference is that they utilize ordered choices instead of the unordered choices used by context-free grammars (CFGs) and other parser generators, such as Yacc or ANTLR. As a result, Rats! grammars avoid ambiguities and support localized changes. Additional flexibility is offered through syntactic predicates, which match expressions but do not consume the input, thus providing unlimited lookahead, and through the integration of lexing with parsing, which greatly simplifies the addition of new tokens to a grammar. PEGs have the additional benefit that they are not only closed under composition (unlike the LR or LL grammars used by Yacc and ANTLR), but also intersection and complement (unlike CFGs in general).
- To eliminate the need for explicit semantic actions, Rats! can automatically generate abstract syntax trees. In particular, it supports productions that return no semantic values (such as those recognizing spaces or comments), string values (such as those recognizing literals or identifiers), and generic tree nodes (potentially all other productions).
- Since some computer-readable formats are inherently context-sensitive and cannot be expressed as PEGs (or CFGs), Rats! supports two techniques for managing parser context or state, thus providing a well-defined interface for extending parsers. First, Rats! provides parser actions to recognize expressions that depend on local context, i.e., expressions that depend on immediately preceding expressions within the same production. An example for such local context is an explicit length preceding as many instances of some expression. Second, Rats! supports a global state object to recognize expressions that depend on possibly global context. State modifications are performed within lightweight transactions, which preserve the basically functional nature of Rats!-generated parsers. An example for a global context is the symbol table used for disambiguating variable and typedef names when parsing C.
Enhancements:
- Release highlights are support for formatting-preserving source refactorings through parse trees, support for parsing and pretty printing Java 5, (an improved abstract syntax tree for Java, and improved support for type checking C and Java ASTs.

Hpodder is a tool to scan and download podcasts. Such tools are often called podcatchers.
Hpodder is a command-line tool for Linux. The project has quite a few features. A few highlights are that it is easy to learn and use, has automatic discovery of feed metadata, and can import iPodder settings.
Enhancements:
- This is the first production release.
- Feeds or episodes that repeatedly return errors are now automatically pruned.
- Cleaning of download areas was improved.
- Bugs were fixed.