Free 37 software for mac

The GUIDOLib project aims at the development of a generic, portable library and API for the graphical rendering of musical scores. The library is based on the GUIDO Music Notation Format as the underlying data format. The library takes account of the conventional music notation system and should be flexible enough to include any graphical sign and musical information if necessary.
The GUIDOLib project includes the development of several applications for tasks like displaying/rendering musical scores (GUIDO Noteviewer), playback GUIDO files via MIDI, or the conversion between GUIDO and and other scorefile formats. Another main topic of the project is the development of the portable library and API for graphical score.
NOTE: GUIDOLib is licensed and distributed under the terms of the GNU Library or Lesser General Public License (LGPL).

Enhancements
- bug in staff management corrected (ARStaff destructor)
- bug in meter without params corrected (failure not implemented)
- bug in float parsing corrected (introduced with Qt support)

Logtalk 2.37.5 brings you canvenience of using such an object-oriented logic programming language that can use most Prolog implementations as a back-end compiler.

As a multi-paradigm language, Logtalk includes support for both prototypes and classes, protocols (interfaces), component-based programming through category-based composition, event-driven programming, and high-level multi-threading programming.

Major Features:

1. Separation between interface and implementation: Predicate directives (declarations) can be contained inside protocols (interfaces), which can be implemented by any object.
2. Parametric objects: Object identifiers can be compound terms containing free variables that can be used to parametrize object predicates. This allows us to interpret predicate clauses as providing instantiations of a parametric object identifier. I.e. through parametric object we can associate any number of methods with a compound term.
3. Support for both class-based and prototype-based systems: You may have, in the same application, class-based hierarchies (with instantiation and specialization relations) and prototype-based hierarchies (with extension relations). Moreover, fundamental language features such as protocols (interfaces) and categories (components) can be used simultaneously by classes, instances, and prototypes.
4. Support for multiple object hierarchies: No need to be constrained to a single, lengthy hierarchy rooted in some generic object.
5. Private, protected, and public inheritance: Logtalk supports private, protected, and public inheritance in a way similar to C++. Moreover, any entity relation can be qualified using a scope keyword. E.g. an object can privately implement a protocol, thus making all protocol declared predicates private.
6. Private, protected, and public object predicates: Set the scope of your object predicates to match your protocol design and let the runtime system enforce your choices.
7. Static and dynamic objects: Objects can be either static or dynamic. Static objects are defined in source files which are compiled and loaded in the same way as Prolog files. Dynamic object can be either defined in source files or created at runtime.
8. Static and dynamic object predicates: Any static object may contain both static and dynamic predicates.
9. Logtalk syntax extends standard Prolog syntax: Logtalk uses standard Prolog syntax with the addition of a few operators and directives for a smooth learning curve. Prolog code can be easily encapsulated inside objects with little or no changes. Moreover, Logtalk can transparently interpret most Prolog modules as Logtalk objects for easy reusing of existing code (e.g. libraries).
10. Event-driven programming: Predicates can be implicitly called when a spied event occurs, allowing programming solutions which minimize object coupling. In addition, events provide support for behavioral reflection and can be used to implement the concepts of pointcut and advice found on Aspect-Oriented Programming.
11. Component-based programming: Predicates can be encapsulated inside categories, which can be virtually imported by any object, without any code duplication and irrespective of object hierarchies. Thus, objects may be defined through composition of categories, which act as fine-grained units of code reuse. Categories may also extend existing objects. Categories can be used to implement aspects and mixin-like behavior without resorting to inheritance.
12. Multi-threading programming: High level multi-threading programming is available when running Logtalk with selected back-end Prolog compilers, allowing objects to support both synchronous and asynchronous messages. Independent and-parallelism and competitive or-parallelism are also supported. Easily take advantage of modern multi-processor and multi-core computers without bothering with the details of creating and destroying threads, implement thread communication, or synchronizing threads.
13. Multi-inheritance support: Logtalk supports multi-inheritance of both protocol and implementation. An object may implement several protocols and extend, specialize, or instantiate several objects. Multi-inheritance conflicts are solved implicitly by the Logtalk lookup algorithms or explicitly by using predicate directives.
14. Good performance: Logtalk code is compiled using the same technics that you use to write efficient Prolog code. In addition, Logtalk supports both static binding and dynamic binding (with method lookup caching), greatly improving performance. Benchmark results for some Prolog compilers are available here.
15. Close integration with the ISO Prolog Standard: Logtalk is designed for smooth integration with any Prolog compiler that conforms or closely follows the ISO Prolog Standard.
16. Compatible with most Prolog compilers: Logtalk interfaces with a specific back-end Prolog compiler via a minimal configuration file making it compatible with almost any modern compiler.
17. Automatic generation of XML documentation files: Logtalk automatically generates a documentation file in XML format for every compiled object, protocol, or category. The system includes all the necessary XSL(T) files and scripts to convert documenting files to (X)HTML and PDF.
18. Dynamic language: Logtalk is a dynamic language that allows hierarchies, objects, protocols, categories, and methods (predicates) to be freely created and modified at runtime. Other dynamic language features include support for meta-programming and both structural and behavioral reflection.

LED CalcX is a simple calculator for LED video displays.
LEDCalcX will provide dimensions, power, pixel info, aspect ratio and other info. This is a useful tool for people producing or designing media that will be displayed on large video screens.
Enhancements:
- Fixed GUI Structure display text/ feedback
- Fixed bug that allows calculation with no value
- reduced the number of decimal places in GUI
- Aspect Ratio display is in proper format
- Reopens in the last state of being closed
- Calculates when value is changed
- 999 > 1 input is validated.

Portable VLC OS X is the VLC video stream and multimedia palyer packaged as portable application so you can carry around with you on any portable device, USB thumb drive, iPod, portable hard drive,memory card, other portable device (also on your internal hard disk) as long as it has 37 MB of free space and use on any Mac OS X computer, taking your preferences with you.
How to install
1. Drag "Portable VLC OS X" folder to your portable device, USB thumb drive, iPod, portable hard drive, memory card, other portable device (also to your internal hard disk) as long as it has 37 MB of free space.
2. Clicking "Portable VLC" will open VLC from your portable device, wait a while before VLC start.
3. If a local copy of VLC is running an alert window allow you to quit it.
Using your data
You can copy your user preferences to Portable VLC when "Copy preferences" window ask you. So, if you wish to use your bookmarks, history, preferences you already have on your system, just click "Yes" when prompt.
VLC application, preference file and folder are inside the bundle:
Portable VLC.app/Contents/Resources/app/
VLC is packaged using the Platypus script wrapper from
http://sveinbjorn.sytes.net/platypus
Support Forum
Post questions, tips, suggestions, clues, helps, bugs to our OS X Portable Applications support forum.
Enhancements:
- VLC updated to 0.8.5
- PPC and Intel available.
- Script code update.

Piero's FileScript Helper 3.1r2 is a full featured and advanced script, which is comparable to a Swiss Army Knife for scripters. It is useful even to non-scripters. Helping to restore files when "something goes wrong" with scripting, it also offers approximately 37 scripting and Finder tasks (with many variations), "Selective Undo" and actions which can be combined.

Requirements: Mac OS 8.6 or higher