Free schemes software for linux

Scheme2Js is a Scheme to Javascript compiler. While some effort has been spent on being as close as possible to R5rs, we concentrated mainly on efficiency.
Usually Scheme2Js produces Javascript code, that is comparable to hand-written code. In order to achieve this performance, Scheme2Js is not completely R5rs compliant. In particular it lacks support for continuations, exact numbers and it treats tail recursion only partially.
Scheme2Js provides several flags, that allow to modify the result:
- --no-js-dot-notation disallows access to JavaScript fields with the dot-notation. This flag disables accesses of the form x.y like in document.getElementById. It is however still possible to access the is a valid expression using the js-field function.
- --mutable-strings: in order to improve the performance of string-operations and to ease the interface between Scheme and JavaScript code, the default implementation maps Scheme strings to JavaScript strings. Contrary to Scheme strings, JavaScript strings are however immutable. This flag maps strings to a JavaScript class, that represents Scheme strings, that are mutable. The resulting code might be slightly slower, and it is more difficult to interface with Javascript code.
- --encapsulate-parts encapsulates the program into an anonymous function. Only global variables are outside of this anonymous function. On one hand this introduces one function call to the anonymous function. But on the other hand most Javascript implementations should run faster with this optimization: usually hashtables are used to represent scopes in JavaScript. By using an anonymous function the programs variables are separated into their own smaller hashtable which (in theory) accelerates accesses to these variables. More importantly the variables are stored in their own hashtable, and not in the global hashtable, which is accessible by the global variable. It is extremely easy to indirectly modify the contents of global variables. Inlining or other common optimizations are hence impossible to do on global variables. By storing the programs variables in an anonymous function these optimizations become again possible.
- --optimize-var-number reduces the number of variables used in the resulting JavaScript code. The code may run faster, but is more difficult to debug, as the variable names are lost and the same variable might be used several times.
- --optimize-while: with this flag Scheme2Js optimizes common while loops. The unoptimized while loops are often of the form:
while(true) {
if(test)
resVar = res;
else {
modify_loop_variable;
continue;
}
break;
}
This optimization looks for these patterns and moves the test into the while loop:
while(!test) {
modify_loop_variable;
}
resVar = res;
This optimization has been implemented only recently and is therefore not yet activated by default.
- --verbose prints some information.
- --no-inlining disables all function inlining (constants might still be inlined).
- --inline-globals lets Scheme2Js inline global functions and constants. This might have two unwanted side-effects: for one, global variables are often used to transfer data between different modules. Some inlined functions are lost if there is no reference to them anymore. If global functions are to be used outside a module, one should not use this flag. (This behavior is likely to change in future versions of Scheme2Js.)
- --unresolved-is-js: if a variable is unbound, the compiler will assume the variable comes from another module, or from JavaScript. See Section Scheme - Javascript for a more detailed discussion of the JavaScript Scheme interface.
- --js-this provides the this variable within Scheme functions. This way, Scheme procedures can be used as methods of JavaScript objects.
- --no-tailrec disables the tailrec to while-loop optimization. If you suspect a bug in the compilers way of translating tail-recs, you could try this flag.
- --no-optimize-calls disables Scheme2Js inlining of binary or unary operations. For instance sci_plus(3, 5) is optimized to (3+5). This optimization is quite important, and theres usually no reason to disable it.
- --no-optimize-consts disables the pre-constant calculation. Unless disabled (with this flag), compound constants are precalculated and their occurrences replaced by a reference to a variable holding the constant. This makes repeated accesses to these constants faster, but introduces new variables.
- --no-optimize-boolify disables the boolify optimization. JavaScripts and Schemes boolify are not equivalent: JavaScript considers false, 0, null and undefined to be false, whereas Scheme only has #f. The unoptimized boolify therefore always adds the test against false: if (test !== false) ... If Scheme2Js can see, that the test itself is a boolean, it can remove the unnecessary !== false test. This flag disables this optimization.
- --d STAGE prints a dot-file (see graphviz) of the AST after stage STAGE. Possible stages are: expand, tree, symbol, node-elim1, tail, inline, constant-propagation, rm-unused-vars, capture, node-elim2, while, (tt "statements"), node-elim3. Usually one doesnt need this flag, unless for debugging purposes.
- --print-locs prints the original locations as comments to the JavaScript file. These locations are currently the character-offset from the beginning of the file.
Enhancements:
- This release adds trampolines.

Inlab-Scheme is an independent implementation of the algorithmic language Scheme and conforms to the R4RS and the IEEE Standard 1178.
In addition to the language core, Inlab-Scheme has support for image processing which allows the implementation of OCR and image recognition applications.
Inlab-Scheme project comes with two built in graphic file format converters which convert the PATIMG patent file format and the ST.33 patent file format to multipage TIFF without decompressing.
Main features:
- Inlab-Scheme is an independent implementation of the algorithmic language Scheme and conforms to the R4RS and the IEEE Standard 1178.
- Inlab-Scheme 4 passes the r4rstest.scm test incuding the tests for continuations, Scheme 4 and delay/force.
- Pretty printing, fluid-let, dynamic-wind and syntax procedures using Inlab-Scheme syntax-lambda.
- Bitmaps: Reading and writing TIFF (G4, single/multipage), XBM and PNG file formats, scaling, rotating, comparing, inverting, cropping, page decomposition (exploding), line drawing, greymap conversions and more.
- Greymaps: 256 greylevel images, reading and writing PNG file formats (reads anything, writes PNG greylevel interlaced/not interlaced), scaling, cropping, conversions to and from bitmaps for further analysis and processing and more.
- Inlab-Scheme Release 4 comes with two built in graphic file format converters which convert the PATIMG patent file format (as found on the USAPat CDROM series of the US PTO) and the ST.33 patent file format (as found on the US PTO PATENTIMAGES CDROM series and the european ESPACE CDROM series) to multipage tiff without decompressing.
- Inlab-Scheme Release 4 comes as a single binary to reduce installation to an absolute minimum.
- Its easy to write Inlab-Scheme scripts that may be invoked directly from your shell using the #!-mechanism.
Enhancements:
- The license was changed to the GPL.
- A code cleanup addressing licensing issues has been performed.

steelme is an open-source theme manager for Java Swing programs. It allows the end user to select from pre-installed themes, or color schemes, or to create his own by the use of the ThemeEditor.

steelme is designed to be lightweight and easy for the application developer to use.

Orpheus is a light-weight text mode menu- and window-driven audio player application for CDs, MP3, Vorbis OGG and internet stream broadcasts.
Main features:
Text mode user interface
- Based on the ncurses library
- Provides windows, menus and dialogs
- Configurable color schemes
- Configuration is done with dialogs
Player
- Supports MP3 (through mpg123), OGG (with ogg123), CD tracks and internet broadcasts
- Saves and loads playlists
- Provides quick access to recent lists played
- Can combine CD, MP3 and OGG tracks in the same playlist
- Edit MP3 and OGG ID tags feature
- "Repeat track", "Repeat play list" and "Random" play modes
- Play list sorting and search options
- Auto-generated currently_playing file which makes it possible to easily find out from other applications what is playing now
- Internal mixer controller
- Command line interface for controlling an already running instance of the program
Network
- CDDB information retrieval for CDs
- HTTP proxy support
- Auto-load of the Internet radio presets directory from the network
Enhancements:
- This release converts from utf-8 for OGG tracks and supports Internet radio.
- Broadcasts can now be added to the playlist along with the other items.
- For the initial stations directory, the presets directory from the screamer-radio project is used.

SVG charter is a project to build a tool to generate charts and graphs with SVG output to allow fully scalable data visualization.
The application came about after my personal frustration with not being able to read tiny GIF charts accurately.
Couldnt be simpler, though. You must run SVG Charter in the directory where the charting modules live. To change which charting module the engine uses, change the "require" call on line 62 of the charter.pl engine code. Then just run the code as follows:
./charter.pl [datafile in CSV format] > thechart.svg
The data file must be in a CSV format with the first row as headings and the subsequent rows as numeric data. Have a look at the data.csv file that comes packaged for an example.
SVG CHARTER LIMITATIONS
Right now the SVG Charter emits a fixed-aspect ratio graph.
SVG Charter can only emit a graph which is limited to 4 data series. There is no technical limitation on the number of data points, but 100 seems to be a practical limitation of whats easily readable.
SVG Charter currently emits fixed color schemes.
SVG Charter cannot configure the Legend location
SVG CHARTER CONTRIBUTIONS
Code contributions to SVG charter will be greatly appriciated. Feel free to tackle any limitation Ive listed above or any limiation you discover.
Enhancements:
- This release supports a very constrained scatter graph.

vpn-shaper provides a dynamic traffic shaper for vpn, poptop, and similar programs, using iproute2.

vpn-shaper is a dynamic traffic shaper for openvpn, poptop, and similar programs, using iproute2. It allows shaping of traffic between many users conected to one server, and it supports different prioritiy schemes for different users and different types of traffic.

Trafic shaping uses the HTB qdisc. Prioritization uses l7-filter and ipp2p and some of the patch-o-matic extensions.

Classification of trafic in HTB classes is done by using the IPMARC patch-o-matic extension.