Free designer software for linux

IceWM Control Panel is a full-featured, GTK-based control panel for IceWM. It features an IceWM theme designer, Ice Sound Manager (for sound events), IcePref2, and tools to manage desktop wallpaper, cursors, keys, window options, and more.
IceWM Control Panel has a familiar, Windows-like Control Panel user interface.
Enhancements:
- This release patches bugs that many users of Python 2.3 experienced while attempting to run the applications.
- In addition, this release adds support for the latest changes and features of IceWM versions 1.2.14 and 1.2.15 .
- This release also features Russian translation updates and French Help file additions .

DWI is an experimental platform for exploring ways of making application development simpler. It is still hard to write large, complex, multi-user, data-driven (SQL-backed) applications.
It doesnt matter if your development platform is the web and Enterprise Java Beans, C# and .net or Mono, or whether its the Gnome/GTK or KDE widget set and the Linux desktop; its still just plain hard.
DWI is an effort to change this situation. DWI currently offers a simple way of developing data-driven (that is, SQL-backed) Gnome applications (designed with the Glade GUI designer).
It does this by avoiding "programming" (or at least, "traditional programming" in C. C#, perl, python or any other "traditional" language), substituting instead a configuration-file like format that defines how various GUI elements should be hooked up to various objects (such as GLib GObjects) or SQL fields and tables.
The current primary effort with DWI is to provide a number of well-documented, easy-to-understand, working examples that show how to use DWI. These examples currently include a stand-alone bug-tracker-like application, examples of integrating with existing GTK applications, and an example of hooking up a Glade-designed interface to a GLib GObject with almost no C programming at all (assuming you have a GLib GObject already handy.
DWI is a fairly simple environment for quickly creating data-driven applications, that is, graphical applications that manipulate and show info from a database. This environment differs from others in that it is focused on native GTK/Gnome support through the Glade GUI designer, and thus allows you to build user interfaces as elegant as you can make them in Glade.
At this point, this system has enough features to be adequate for creating form-editing and reporting applications. Multiple SQL database vendors are supported through ODBC or libdbi drivers. There is a simple db-driver infrastructure so its easy to support for additional SQL APIs. The system supports all of the basic Gtk widgets, and an additional half-dozen Gnome I/O widgets, such as GnomeDateEntry.
DWI is powered by an engine that has some fairly generic procedures for mapping fields, such as SQL table columns or widget values, between each other, and also between other things, such as objects, hash tables and etc. In a certain sense, the engine can be thought of as an Object-to-Relational Mapping (ORM), mapping SQL to several object systems, including Glib GObjects and QOF. This engine has been designed so that it becomes easy to add support for all kinds of new object systems: i.e. for the engine to be a generic re-mapper between not just SQL and GTK but between many different types of object systems and data sources/sinks.
Built on top of this engine is a DWI application that parses an XML-based file, the "DWI file", that describes the connections between glade widgets (or objects in general) and database tables. Currently, the only way to create DWI files is by hand. Unfortunately, this can be a fairly long and laborious process itself, especially when creating something a bit more sophisticated. In the future, we hope to have an extension to Glade, or possibly an extension to a database-browsing tool that will allow you to graphically make such connections. (Work has begun on such a tool, written in DWI itself).
The grim reality is that DWI wont ever become popular without a graphical designer. Although fairly complex apps can be readily created using DWI, it does have a non-trivial learning curve. When we say "can be created quickly", we mean "days" or "weeks", as opposed to "months" for traditional database application development cycles. Graphical RAD tools have a way of being brainlessly pleasant to use, and give the impression of an even faster development cycle, even though the learning curve is identical.
Note that the design of the XML format is sufficiently generic that it is not directly tied to Glade. It should be straightforward to adopt other ORM markups to inter-operate with the DWI engine. It is also envisioned that other GUI object systems, such as PHP, could be used with DWI, so as to create data-driven web pages. That is, Glade is currently the only GUI driver, but other drivers for other GUIs should be possible.
Enhancements:
- Changed to use automake Makefile system for easier installs; make install target now works.
- Segregate gtk and qof features to own subdirectories, so that apps which do not nead gtk do not need to link to the gtk libraries.
- Add support for QOF objects, including multiple examples of using QOF.
- Finish modularize of the SQL db drivers, so that only the required driver is actually loaded.

The BugPort system is an open-source, freely available, web-based system to manage tasks and defects throughout the software development process.
BugPort is written in the cross-platform PHP language (using its object-oriented capabilities) and uses a relational database for storage/querying.
BugPort is in heavy use by INCOGEN for internal management of software development and QA.
Main features:
Team productivity
- Portal-based Homepage - provides quick summary view to allow user to determine what issues to address next
- Keyword Searching - uses MySQL (or, soon, Oracle) keyword searching features to allow fast text-based searches (of ALL text fields for each issue)
- Quick Search - users can search by keyword or issue ID from any page in the system
- Color coding - subtly provides information on priority and highlights important information
- Favorites Groups - users can create and share arbitrary groups of issues to improve communication
Process control
- Manages defects, tasks, and feature requests
- Supports Multiple Projects
- Manages attachment files
- Helps track related issues
- Allows multiple permission levels using User Types - Designer, Developer, Tester, Lead Tester
- Sends automatic e-mail notifications for issue changes
Project analysis
- Generates and reports historical statistics
- Tracks estimated and actual design and development hours
System foundation
- Easy to use
- Built on an easy-to-use INCOGEN-created PHP development API for simple code extensibility and re-use
- Most BugPort pages are built in less than 1 second (when running on a 1GHz Pentium server)
- Caches data extensively for performance boosts - achieved with the help of the excellent ADOdb PHP package
- Provides cross-platform compatibility

GSpeakers is a loudspeaker design program designed for the Gnome desktop.

GSpeakers is built using the Gtkmm libraries (C++ wrapper for the Gtk+ libraries http://gtkmm.sf.net).

The reason I started to work on this program was that I could not find any other Gtk/Gnome based loudspeaker design program. The question I had to ask myself was: How can I make it easier to design loudspeakers?

GSpeakers aims to be easy to use but still powerful enough ful the experienced loudspeaker designer.

John the Ripper is a fast password cracker, currently available for many flavors of Unix (11 are officially supported, not counting different architectures), DOS, Win32, BeOS, and OpenVMS.
It supports several crypt(3) password hash types which are most commonly found on various Unix flavors, as well as Kerberos AFS and Windows NT/2000/XP LM hashes.
Several other hash types are added with contributed patches.
Enhancements:
- Bitslice DES code for x86-64 that makes use of the 64-bit mode extended SSE2 with 16 XMM registers has been added for better performance at DES-based crypt(3) hashes with x86-64 builds on AMD processors.
- A new make target for FreeBSD/x86-64 has been added.

JGlade is a reimplementation of libglade in pure Java that enables Glade UI designs to be ported to platform independent toolkits, like SWT and Eclipse.

Toolkits are managed through an Abstract factory, and pluggable modules supporting other toolkits can be implemented.

Glade UI designer produces an XML file describing the interface in GTK+ terms, this file is parsed by JGlade and a new SWT interface is constructed making the necessary conversion from GTK+ to SWT or other toolkit.

Openwall tcb suite package contains core components of our tcb suite implementing the alternative password shadowing scheme on Owl.

It is being made available separately from Owl primarily for use by other distributions. Note that you need to have the password hashing framework introduced with crypt_blowfish patched into glibc to compile and use this.

The package consists of three components: pam_tcb, libnss_tcb, and libtcb.
pam_tcb is a PAM module which supersedes pam_unix. It also implements the tcb password shadowing scheme.

The tcb scheme allows many core system utilities (passwd(1) being the primary example) to operate with little privilege. libnss_tcb is the accompanying NSS module. libtcb contains code shared by the PAM and NSS modules and is also used by user management tools on Owl due to our shadow suite patches.

WAusers application is one component of the WAhelper Web accessibility testing suite.

WAusers serves for managing Web accessibility testing sites where users can register, create their own Web accessibility testing projects, and log into all their projects using a single global password.

Web pages are often designed without handicapped users in mind. Despite there exist Web accessibility guidelines such as W3C Accessibility Guidelines or U.S. Section 508 law, many Web designers are not aware about problems they cause to handicapped visitors of their pages. And even when a Web designer tries to make Web pages accessible, he may not be aware about all the obstacles handicapped users can meet.

- Software tools can be helpful here. Several Web accessibility checking tools already exist, but they have various problems:
Most of them are non-free and you cant use them freely to evaluate accessibility of your website effectively. Making things accessible means removing barriers and it is important to make the barriers as low as possible.
- New tests usually cant be added easily. An easily extensible and freely modifiable tool is needed so that its features can be improved efficiently. A good and maintained tool can make the whole process of making Web pages accessible more effective.
- The tools often dont try to go beyond semi-automated tests. But there are many accessibility problems which cant be detected, diagnosed and reported without human assistance. A tool helping humans with the testing process is needed.