Free units 0.3 software for mac

Major Features:

1. Provides unit test framework for ActionScript 3 code in Flex and ActionScript 3 projects and libraries.
2. Graphical Test Runner to run unit tests

Enhancements:

• Based on revision 20 of as3flexunit project hosted on google code, with bug fixes and the addition of a new graphical test runner.

Requirements:

• Mac OS X

Burr Tools will help you solve a certain kind of puzzle.
Namely puzzles that are made out of square or dice shaped units and whose solution also contains only rectangular aligned pieces.
Main features:
- Does nearly all that PuzzleSolver 3D which is
- You can enter all puzzles that are assembled out of dice shaped units
- Find assemblies for you puzzle
- Disassemble the found assembly them
- Show everything in a 3 dimensional image
- Animate how the puzzle has to be assembled
- Toggle the visibility of pieces in the solution to have a look at the inner workings of a puzzle. This is especially helpful for box packing puzzles
- Runs on Windows and Linux and probably is also compilable on MacOS
- You can specify which cubes to fill and which can be empty or full. PuzzleSolver 3D has only 2 modes. Either all cubes may be left empty in the solution, or the cubes that have an empty neighbor must be filled. BurrTools are more flexible here.
- More than one problem in one file (e.g. have several Soma Cube problems in the same file)
- Constraints to piece placements (like checkerboard)
- Group pieces together to tell the disassembler that they dont need to be taken apart this is necessary for puzzles like "Cube In Cage" where the cage can not be taken apart but has 3 movable pieces
- No limits to sizes and number of shapes. As long as your computer has the memory and you the patience the program will do it for you, even if it takes eons.
- Free as in beer. It doesnt cost you anything
- Free as in speech. The source is available, so you can do your own programming or help me improve continue improving the program in case I have to stop working on it.
- Save puzzles with solutions in compressed XML-files. This allows you to create puzzles with other means (like your own burrgrower, ...)
- A library is provided that helps you to write your own software for puzzle design and analysis.
Enhancements:
- The assembler sometimes didnt find existing solutions. This happened when the total of all voxels defined by lower ranges was larger than the number of normal voxels in the result
- The solver did abort in cases when piece ranges were used and some pieces didnt have a mirror partner piece
- A Possible crash with very larger grids
- A missing symmetry in the triangle grid
- A crash in the sphere grid when empty (no used spheres) pieces were used
- A crash when animating a solution while the solver is running and that solution has already been dropped due to a limit on the number of solutions

This is a Mac OS X Dashboard widget based on the Def Logic game, Defense Unit by Brent Silby. It is a fast paced arcade game in which you control a turret and need to shoot down space ships, tanks, and more. There are multiple levels, all of which have bosses, new enemies are brought into almost every level, and its always full of fast paced action.
Main features:
- A fast paced arcade game with multiple levels and enemies.
- A large gameplay space so that no detail is sacrificed, but a minimize/maximize button so that it almost disappears when it is not in use.

Ophiuchus is a multiplayer space strategy game in a similar vein as the Master of Orion series.
It is a very early alpha release, and as such is currently very minimal but playable and networkable.
The game map is a rectangular board of tiles. A tile may contain a star. Each star is orbited by a single inhabitable planet. Each player starts out inhabiting a single planet, and owning 10 units of money.
Each planet a player owns adds 1 unit of money to their treasury per turn.
You may build spaceships at your colonies, which cost 4 units of money, and take 1 turn to construct. Spaceships move across the map at a rate of 1 square per turn. If a fleet encounters an uninhabited planet, it will automatically colonise the planet. If you encounter a planet owned by another player, you can attack and invade it.
Combat works on the simple principle of winner-takes-all. Whichever side has the larger fleet destroys the other side. You win the game by invading all colonies held by all other players.
Enhancements:
- When multiple players arrive at the same uncolonised system at the same time, none of them can colonise the planet. Previously, the player with the lowest ID got the planet, leading to an advantage to players with lower IDs. This was a problem especially in single player, where it gave a great advantage to the player over the computer.
- Attack commands now always give feedback.

NEV2lkit is a preprocessor program for loading and saving neuronal event data in different formats (ASCII based, NEV1.0,1.1 or NEV2.0 format). Neuronal signals can be extracted from up to 256 continuous sampled input data streams in a file. The spike data can be sorted into "units" in single or cross many experimental files (the amount of RAM is the limit).
Enhancements:
- Bug fixes.

EMGM is a free and open source general-purpose Haskell library for generic programming with type classes.
The design is based on the idea of modeling algebraic datatypes as sum-of-product structures. Many datatypes can be modeled this way, and because they all share a common structure, we can write generic functions that work on this structure.
The library provides three main components:
- Common - A common foundation for building generic functions and adding support for datatypes. This includes the collection of datatypes (e.g. sum, product, unit) and type classes (e.g. Generic, Rep), that are used throughout the library. This is what you need to define your own generic functions, to add generic support for your datatype, or to define ad-hoc cases.
- Data - Support for using standard datatypes generically. Types such as [a], tuples, and Maybe are built into Haskell or come included in the standard libraries. EMGM provides full support for generic functions on these datatypes. The modules in this component are also useful as guides when adding generic support for your own datatypes.
- Functions - A collection of useful generic functions. These work with a variety of datatypes and provide a wide range of operations. For example, there is crush, a generalization of the fold functions. It is one of the most useful functions, because it allows you to flexibly extract the elements of a polymorphic container.

Main features:
- Datatype-generic programming using sum-of-product views
- Large collection of ready-to-use generic functions
- Included support for standard datatypes: lists, Maybe, tuples
- Easy to add support for new datatypes
- Type classes make writing new functions straightforward in a structurally inductive style
- Generic functions are extensible with ad-hoc cases for arbitrary datatypes
- Good performance of generic functions

System requirements:
- GHC