Are you looking for a lite weight GUI framework for your programming language ?
Are you a programming language developer ?
Are you looking for a lite weight GUI framework for Windows to build your programming language on ?
The Computer Workshop, developer of the EZGUI 5.0 Professional GUI framework for Windows, is looking for companies interested in licensing a powerful Windows GUI framework as a backend for a programming language. So why use EZGUI 5.0 as your GUI framework ?
Simply put, it has amazing power with possibly the smallest footprint ever for a Windows based GUI framework. Not even Microsoft has ever produced this small of a GUI framework with this much raw power.
Consider key areas where EZGUI excels:
Amazingly small footprint
EZGUI’s framework is made up few small standard Windows DLL’s. No COM is used and EZGUI is 100% procedural in nature, rather than OOP based. The core WIN32 API is procedural based as well, so EZGUI requires minimal code to accomplish what it does. EZGUI only uses the core WIN32 API internally, with no COM, no dot.net, or any other backend framework. For 3D graphics EZGUI taps into the standard OpenGL 1.0/2.0 API’s.
EZGUI has a number of built in proprietary engines, which accomplishes things not native to the WIN32 API directly, such as a 2D Sprite engine (no DirectX required), a 3D scripting language (uses OpenGL as backend), a number of custom controls not found in the WIN32 API, etc. So how big is the EZGUI framework ? About 1 megabyte in size. Yes, the entire EZGUI runtime engine (DLLs) can fit on an old fashioned floppy disk. EZGUI’s runtime can do more than classic Visual Basics core runtimes at 1/3rd the size and without the need for OCX controls for things like common dialogs or the common controls. But classic Visual Basic didn’t have built in support for 2D sprite graphics, image effects, 3D OpenGL animation, etc. The core EZGUI runtime is just one DLL which is about 700 KB in size. The majority of features are supported in this one DLL. A few extra, much smaller DLL’s provide things like OpenGL 3D, Masked Edit control and a simply BTree database engine.
Runs on majority of Windows versions from Windows 98 to Windows 10.
EZGUI was designed to dynamically test the operating system to see what features are available and tap into features found in later versions of Windows, while still being able to run on older, legacy, versions of Windows. Windows XP is really the lowest version of Windows you should use EZGUI on, but it can run on Windows 98, NT and Millenium. Actually it can even run on some versions of Windows 95, but I don’t recommend it. EZGUI accomplishes this using a simple technique found in the WIN32. It can load an OS DLL, test to see if an API exists, and if it does call that API via pointers internally. This means the EZGUI runtimes are not going to fail at startup because an OS API is missing on one particular version of Windows. The majority of features though should run on Windows XP fine.
EZGUI was designed so it avoided the use of “leading edge” API’s and instead was built upon API’s which have long existed in Windows. This means less problems with “missing” API’s on older versions of Windows. This does not mean that EZGUI is limited because of this though. Its own proprietary engines replace the need for many leading edge API’s. For example, its 2D Sprite engine does not use DirectX and can even work on some legacy PC’s as far back as Windows 95. Yet it is very fast and very powerful.
A real WIN32 framework for business apps, not a gaming engine
EZGUI was designed for handling real Graphic User Interfaces for business style apps, rather than simply a graphic only UI framework, like some gaming engines. It produces real Windows and controls, not simulations via low level graphics. Even its 2D and 3D Graphic engines are designed as part of real WIN32 custom controls. I have seen many a 2D and 3D graphic engine for Windows, but often they are simply single window (or full screen) graphic engines based on DirectX or OpenGL. EZGUI produces real Windows forms and controls. You can place multiple 3D controls on the same parent form as real custom controls. Few programmers today know how to write real WIN32 custom controls, but EZGUI was built using such knowledge.
A programming language is nothing without a real drag and drop Visual Designer
If you want to create a real professional programming language, you can’t do so if it does not have a real visual design front end. Try imagining classic Visual Basic without the visual part.
EZGUI’s GUI framework has a “drag and drop visual design” engine built in. Yes, it was designed for building visual designer front ends. The version of EZGUI 5.0 Professional currently sold to Powerbasic users even comes with a real drag and drop visual designer/ code generator which was written using the EZGUI framework. EZGUI has its own drag handle control and a rubberbanding engine for drawing controls, plus a subclassing engine which allows drag and drop for any control the framework supports.
It is an extendable framework
EZGUI was designed to be both low level and high level. The low level parts make it possible to extend the framework far beyond what the framework currently does. It has its own subclassing (tap into existing controls low level window procedures) and superclassing (create new control classes from existing ones) engines. EZGUI’s OpenGL control actually uses this superclassing engine to add 3D on top of EZGUI’s own 2D Canvas control. More custom controls can be created using these features.
EZGUI also supports key WIN32 customization features, such as ownerdraw and customdraw which allows customizing existing controls such as the button, listbox, listview, treeview, etc.
It is a programming language in of itself
EZGUI’s command set could be considered a programming language in of itself, with a command set of about 1000 commands, not counting its built in scripting languages (Turtle Graphics, 3D OpenGL, MCI). By using the EZGUI framework as a backend to your programming language, you immediately get a large programming language command set. You just need to handle the other non-GUI features, such as logic, match, file support, etc.
No memory management required
The GUI framework, does not require an memory management from external programming languages which use it. You only need to write the memory management for the parts of your language which your compiler does of its own. EZGUI uses the WIN32 OLE string data type for passing strings to its command set and then back to your program. You simply write your variable length string data type to use the WIN32 OLE API’s and EZGUI does the rest. If your language does not support variable length OLE strings, then your compiler then would have to convert between its string format to OLE before calling the EZGUI framework.
The simplest procedural based app syntax you likely have ever seen
EZGUI’s framework does not require any OOP or classes to work. Unlike the WIN32 API, almost all of the command set need only be passed simple data types and no structures in most cases. There are only a few cases where a structure is used as a datatype, but that is for the print engine and a few of the low level extensions used when for extending the framework. But in most cases simple data types are all that are used.
An app using the EZGUI framework only requires 3 required procedures, no matter how many forms/windows you have. Forms in EZGUI have names, not handles, so they are easier to reference. Controls have ID numbers, just like what is done in normal WIN32 programming. I kind of liken it to “street names and house numbers”, but instead you have “form names and control numbers”.
The EZGUI framework actually takes control of your application. It is called at startup and passed 3 pointers to the three key procedures in your app, EZ_Main (where your app starts), EZ_DesignWindow (called when a form is created and where you can add controls to it) and EZ_Events (its event engine routine). Your app only gets accessed when one of these procedures is called. No WIN32 messaging is required. Your app uses the one of the simplest event engines ever designed for Windows apps.
C not required for using the framework
While one could use this framework with a C compiler (as long as it supports the OLE string data type), the framework was written in Powerbasic, so it is well suited to even BASIC language compilers (again requiring the OLE string data type). So if you are writing a BASIC language compiler, EZGUI would be well suited for that.
Why OLE strings ?
Why does the framework use OLE for string data types ? The framework was written in Powerbasic and Powerbasic uses OLE for strings. OLE is much better for variable length string data types than the CHAR character (fixed length string) often used in C. OLE handles the memory management stuff for you and it can also allow any binary character be embedded including binary zero. It handles its own length tracking, so you don’t require a terminating zero in the memory buffer. If you designing a programming language, you should seriously consider using OLE to handle the variable length string data type. Classic Visual Basic actually uses OLE internally for something similar.
So why use EZGUI for a programming language GUI framework ?
It is amazingly tiny at only about 1 megabyte in size. It has a huge feature set , despite that tiny size. It provides features far beyond the typical classic Visual Basic core GUI features and at 1/3rd the size of the core VB runtimes. It is fast, being written in Powerbasic, a native code compiler. It is easy to use, with a command set designed for ease of use and simplicity. It is based on the WIN32 and does not require dot.net or COM. It uses OpenGL, instead of DirectX, for its 3D engine, which makes it less problematic when it comes to Windows versions. Tiny size is a must today with the emphasis on mobile and lite weight Windows devices (x86). Some Windows tablets come with only 16 GB or 32 GB of disk space, so size does matter. It supports legacy PC’s as well, which makes it better suited to business and corporate needs, since many businesses still need to support legacy hardware.
EZGUI will soon be available for custom licensing for use in programming languages
EZGUI is well tested, being in its fifth generation now. Powerbasic users who have been using EZGUI for many years can attest to its reliability and raw power. The first version of EZGUI was created about 17 years ago and with hundreds of users over the years has been well tested in the real world. EZGUI can be customized to your needs, with a number of options available. The cheapest route would be to simply license the binaries for use with your programming language. Other options though are available, such as the source code for its visual designer which can be customized for building your own visual front end, as well as the core framework source code. If you are a large company with the necessary resources, licensing the runtime source code would allow you to convert it to C, if necessary in the case where C is your primary language. The source code is written in Powerbasic which is an easy language syntax to work with, so it would make conversion to C likely not too difficult.
If you have questions about this new service, making EZGUI available for use as part of programming languages, then feel free to contact me.
Email me (Chris Boss) at:
Small, as well as large companies are welcome
If you are a small business and think something like licensing EZGUI would be too expensive for you, be assured that I am willing work with companies of all sizes. A license to use a binary version of EZGUI for inclusion with a programming language could be purchased for as little as $500 (US) along with a very small royalty per copy sold. Large corporations, which can afford it, have the option of a license with no royalties and even source code for the designer and GUI framework and allowance to port to any language they choose. So no matter the size of your company, I can likely work out some option which would benefit you.
Want to see EZGUI in action ?
Would you like to see EZGUI in action ? Here are some downloads which may be helpful and some videos on my youtube channel which can tell you more.
WIN API backward compatability test app (demonstrates runtime features)