My-T-Soft Build-A-Board Touch Screen Keyboard Software

SKU: Build-A-Board
Contact us for pricing

Qty: - +
   - OR -   

My-T-Soft Build-A-Board  - Touch Screen Keyboard Software

Finally, A Secure, Reliable, Cross-Platform, Designer User Interface! 

Build-A-Board's Virtual Keyboard User Interface Utilities are the answer for any end-user, developer, integrator, or manufacturer who wants alternatives & options to a basic on-screen keyboard. In secure environments, controlling what features & functions are available to the operator can be extremely important, and Build-A-Board gives you the power you need!

Build-A-Board is the answer for anyone who needs to have complete control over the user interface when working with a touch screen, rugged / tablet / mobile pc, or pen based system. Of course, it also works with every other kind of pointing device, including a mouse, trackball, head-mouse, foot-mouse, etc.

Replace outdated equipment with new systems utilizing today's pen or touchscreen input technology, while preserving existing methodology & procedures - Familiar interfaces eliminates the need for additional user training!

Other solutions include users with Special Needs using non-traditional Assistive Technology devices... 

Now, anyone can create custom touch screen keyboards with interactive buttons, virtual input panels, and keyboards on-screen that seamlessly integrate into any application, roll out on any platform, provide operator security, are easily modifiable, yet still provide the ultimate user interactive experience. Whether you're on a touch screen, mobile, pen, playbook, ruggedized tablet, smartphone, tablet pc, or ultra mobile system, you now have the right set of tools. And it easily integrates into any low or high level programming environment with our SDK Developers Integration Kit!

Build-a-Board can generate it's own multiple software input panel run-time targets for Windows CE thru Windows 8.1 (including Embedded and Terminal Services), Linux, and Mac OSX, or create and add layouts to IMG's My-T-Soft Family (My-T-Pen, My-T-Touch, My-T-Soft, My-T-Soft Terminal Server, and OnScreen with WordComplete).

With Build-A-Board you can.

Create or re-create any virtual input panel or on-screen keypad
Replace old legacy membrane panels with virtual (re-programmable) replicas
Shape panel layouts to fit application frames. Like an L-shaped keypad!
Select Colors of Text, Keys, and Panels
Use High Resolution 3D Text or Images on Keys or Buttons
Select Fonts
Build & Test within the Builder Environment(does not require Target system)
Cut/Copy/Paste Keys
Drag & Drop keys for quick & easy layouts
Align keys - Top/Left/Bottom/Right/Horizontal Center/Vertical Center
Evenly Space Keys / Center key or Keys
Size Keys to match Width/Height/Both Width & Height
Create keystrokes along with full-featured macros in Key Action
Built-in Commands: Close, Minimize, Save Position, etc.
Anyone can build the exact screen keyboard or Virtual Software Input Panels (SIP) they need
Cross-platform, Touch screen keyboard software user interfaces for all major Operating Systems!

Designer with Cross Platform Run-times for

Windows CE, XP, Vista, 7, 8, Linux, Mac, more!
Custom, On-screen Keyboard User Interfaces
& Touch screen Keyboard Software Panels
Ideal for Automation, Factory, Kiosk, Medical,
Mobile, SCADA, Tablet, Touchscreen systems

Open different layouts from user-accessible keys or manage programmatically
Play Sounds (Wave / MIDI files)
Run External programs, Shortcuts, Use File Associations to launch host apps
And a whole lot more!
The Ideal Complement to Pen, Tablet, & Touchscreen based Systems!


Drag and drop keys with modifiable labels, actions, views
Multiple target platforms - Windows CE thru 8.1 (including Embbedded), Linux, Mac OS X, (Android in beta)
Create any on-screen keyboard, touch screen keyboard, virtual input panel, or on-screen membrane panel
Create shaped panels to fit available application screen space, such as L-shaped layouts
Replace old legacy membrane panels with re-programmable on screen panels
Select Colors of Text, Keys, and Panels
Use High Resolution 3D on keys
Drag & drop images / add images to keys and panels
Select Fonts
Build & Test within the Builder Environment locally (does not require Target system)
Cut/Copy/Paste Keys
Align keys - Top/Left/Bottom/Right/Horizontal Center/Vertical Center
Evenly Space Keys
Size Keys to match Width/Height/Both Width & Height
Center Key or Keys
Create keystrokes along with full-featured macros in Key Action
Built-in Control Commands: Close, Minimize, Save Position
Open different layouts from user-accessible keys or manage programmatically
Play MIDI files (on supported platforms)
Play Sounds (Wave files) (on supported platforms)
Run External programs, Execute Shortcuts, Use File Associations to launch host application
Save and Manage projects
Builder provides development environment for boards with 1 to 250+ keys per board



On-Screen keyboard software written as standard Windows application
Compatible with all properly written Windows applications
Developed in C/C++ - written at same level as operating system for maximum capabilities
Accesses low-level operating system API via standard interfaces/system libraries - No frameworks or special environment required
Field proven technology since 1993
Cross-Platform keyboard software written at system level
Compatible with all major operating systems - Windows, Mac OS X, Linux
Structured design - target specific functions, shared core keyboard functions, abstracted system API functions
User and System option support
Flexible/modular design
Keyboard layouts as binary data files for minimal space requirements
Fully emulates physical keyboard
Program / Data approach - Program (run-time target software) and separate Data (Keyboard layout) design provides maximum flexibility for multi-platform solutions
Builder, Project Text files, Project database, multiple target output design creates open-ended options for layout creation
Separate user-interface, event handler/virtual input processor design creates open-ended options for end-user/target operation
Separation of Key Label/visualization and Key Action (event) within user interface allows open-ended options
User, developer, and integrator command and control options
Provides ability for user to operate without need for physical keyboard
Operator mode for secure application integration
Developer's Kit (SDK) for controlling and manipulating keyboard
Modular support options/capabilities
Custom views/colors/key images
Transparency (on supported platforms)
Windows logon options
External Support utilities (Developer's Kit)
Extensive feature list
Unique and specialized features to address customer needs
Detailed help, documented options, on-line knowledgebase
Advanced Technical support, programming, and program level integration assistance available

Build-A-Board Quick Usage Notes

Build-A-Board Windows User's Guide

Build-A-Board sample layouts

Technical Information

Build-A-Board provides a Builder tool which is a standard Windows Application, that is used as a development environment for laying out one or more boards with any number of keys. Each project/custom board can be targeted towards any supported platform (platform license may be required). Each supported platform provides target specific run-time files or target-based install package.

Build-A-Board was designed from the ground-up to be a cross-platform, multiple target custom keyboard design tool. The Build-A-Board Builder is the developer front-end that can manipulate keyboard layouts, look, and features. The Run-Time Targets are the actual software (Program) that runs on a target system to display and operate the keyboard layout (Data). Due to the various nature and aspects of the different run-time operating systems and environments, there are features and capabilities that may not translate from one system to another. Also, with over 15 years of providing keyboard solutions, and a half-dozen keyboard file data formats, there are also other constraints that may affect a particular target.

The actual code-base for the run-time targets is a combination of target specific code, shared core keyboard software code, and shared lower-level abstracted operating system API code. Because the foundation was designed to be cross-platform, and extensible, the ability to run the same keyboard layout (Data) on multiple run-time targets (Programs) is the expected operation.

Build-A-Board is the result of constant input and feedback from customers, integrators, developers, and OEMs on what a flexible on-screen keyboard/user interface tool needs to do. Engineered using a disciplined/modular/cross-platform approach, Build-A-Board is the professional's choice for any serious customer or enterprise based deployment.


What is Build-A-Board?

Part of the My-T-Soft® family, Build-A-Board is a suite of utilities that provide tools to create and operate on-screen keyboards, panels, and buttons for creating user interfaces that provide optimal interaction while offering secure levels of operator / user input control. These enhancements allow touchscreen, hand-held, wearable, wireless, ruggedized, tablet and pen-based computer users to operate these systems without the need for a physical keyboard. This results in space saving; reduced hardware costs; quick & low-cost user-training; cleaner machine interfaces; better security; allows enhanced enabling of legacy equipment retrofits; and provides a realization of new & innovative approaches for computer users.

With Build-A-Board, keys, buttons, and panels can be customized as desired, whether to control access, or sized to permit accurate entry even with large gloved hands. Unlike high-level environments and single purpose applications, the native, system-level run-time program can interoperate across all applications. Beyond keyboards, the potential is endless: A complete user interface can be built as a front end to legacy terminal based operations, as an augmentative solution for a disabled individual, or as a custom touchscreen based controller, etc., etc.

Build-A-Board is the evolving culmination of years of experience working with the needs of system providers & their use of IMG's successful My-T-Soft® family of on-screen keyboards. Developed to meet the needs of manufacturers, integrators, developers, and end-users of touchscreen & pen-based systems, it is the Ultimate Tool for anyone with a need for virtual on-screen keyboards & keypads.

Do Build-A-Board layouts work with My-T-Soft® / My-T-Touch® / My-T-Pen®?

Yes. Build-A-Board kbf's (keyboard files) can be used in IMG's OnScreen, My-T-Mouse, My-T-Pen, My-T-Soft, and My-T-Touch products. If you don't have any of these, you can also create a run-time (lite) version of My-T-Soft from within Build-A-Board for Win CE thru thru Windows 7 (including Embedded) to use your layouts.

What is the difference between the Run-Time files and Build-A-Board? How does the licensing work?

The Run-Time files are used on the Target system, which is often different than the development system. For example, if you are developing several keyboard layouts for a Windows CE unit with a MIPS processor, your Run-Time files target would be Windows CE - MIPS. The Run-Time files are licensed separately from Build-A-Board (since they may be placed on 1 or 100 or 10,000 systems). The Build-A-Board Builder (development environment for the keyboard layouts) is the tool used to create, design, modify, and manage keyboard layout files & select different Run-Time targets based on your needs.

Typically a customer would need only 1 or 2 Build-A-Board licenses, since only the developer, integrator, or IT department would be customizing a board or boards. Once it comes to deployment, a license for each run-time system running the keyboard layouts is required.

With the release of the 2.20 version and support for Mac OS X and Linux, platform licenses are offered that address different deployment options based on locations, number of employees, and platforms needed. All of the platform license options do not have unit based licenses, as deployed run-times are already licensed and royalty-free. Refer to Build-A-Board Standard (Cat. #12402), Single-site (Cat. #12415), Multi-Site (Cat. #12416), Enterprise (Cat. #12417), and Global Enterprise (Cat. #12418). Contact IMG Sales for further details.

For small roll-outs, as an example, if you have 8 forklifts with panel mount touchscreen systems, and need numbers, tab, enter, and backspace, a large customized board might be ideal. In this case, the Build-A-Board Builder Tool + 10 Run-time Licenses, Catalog#: 12403 might be the best choice. If you are prototyping and testing, Build-A-Board Builder Tool, Catalog#: 12401 would be sufficient. If you already have licenses of IMG's My-T-Soft®, My-T-Pen®, or My-T-Touch® installed, and want a custom board, then Build-A-Board Builder Tool License, Catalog#: 12401 is all you need. Please note that there are different license options available based on customer needs, so if you can't find exactly what you want on the web site, please contact us.

What operating system do I need?

To operate Build-A-Board you need: Windows 7 / Vista / XP / 2000.
Run-Time Files will work on: Windows CE or Windows 95/98/Me/NT/2000/XP/Vista/7/8/8.1, Windows Server and Embedded versions. Mac OS X 10.4 and higher, and Linux 32-bit/64-bit. For other platforms, or if you have more specifics, please feel free to contact us.

What about Unix, Linux, or Mac OS X?

With the release of the 2.20 version, Mac OS X and Linux are now available. (Note: For Unix, pre-built run-times are not included, as these types of deployments tend to be customer specific - please contact IMG for further details)

I have Build-A-Board 2.10 license - What are my options with the 2.20 release?

Where is my free upgrade?
With the 2.20 release, there are new licensing options. For 2.10 customers, we will be providing a free upgrade to the builder itself, which can still make ANSI 2.10 layouts. We are waiting, however, for the Release 4 update before formally doing this upgrade (the license manager needs to be created for Linux and Mac OS X). If desired, we can provide the BAB220 serial # at this time, so you can license and work with the current Release 3. Please note that you will still have to license individual run-times. Please contact IMG Customer Service with this request.

The new license options are what we refer to as Platform licensing, and it is based on company size, not # of units. Once you have a Platform license for Windows, Linux, Mac OS X, etc. you will be able to produce licensed versions for the licensed platform that can be imaged or deployed without any run-time/per unit licensing. The Build-A-Board standard upgrade (for 1 platform) from a 2.10 license - Catalog # 12406 - this can be ordered on-line (with your BAB210 serial #) with this link:

Upgrade to Build-A-Board 2.20 Standard Platform license
You can then select a platform (Windows/Linux/etc.) and then when you build Unicode 2.20 layouts, the license is automatically embedded in the built layouts, allowing you to deploy without any further license steps. Note that you cannot resell these licenses - these are for you/your company as the end-user. If you wish to distribute / resell licenses, you need an annual distribution license.

To summarize, and hopefully clarify the above, here is what will happen to 2.10 licensees:

1) Free Upgrade to Build-A-Board 2.20/builder - able to use upgraded builder tool, can still make ANSI 2.10 layouts, run-times still licensed separately - Option to license and run Unicode 2.20 layouts by licensing run-time versions

2) Or pay for Upgrade to Platform license (Cat #12406 for Standard - company less than 50 employees)
(There are additional options for site/multi-site/enterprise/global enterprise licenses - please contact IMG Customer Service)

3) for any distributor/reseller and annual distribution license is required.

I'm new to IMG's Build-A-Board - what is the high-level / birds-eye view?

How do I implement a custom keyboard in my application [using Build-A-Board]?
You need the Build-A-Board Builder to create or modify layouts, change key properties/actions, and create/build the KBF (Data) file. For the Target (run-time) you need the My-T-Soft program (for the particular platform) on the run-time system. Drop in the KBF data (default KEYBOARD.KBF), and run the My-T-Soft program - the layout will be displayed to the user, and its operation will be defined by the layout properties / Key Actions (which, of course, are modifiable within Build-A-Board).

What is the Builder for?

The Build-A-Board Builder itself is just a front-end designer tool to allow you to drag & drop keys, resize, change properties, etc. It is a user-friendly front end to designing keyboard layouts. When you build, you are creating the single file KBF that can be dropped into a target system (which then contains the Keyboard layout/properties/etc.) The KBF layout is supported on Windows, Windows CE, Linux, Mac OS X, etc.

As much as possible, the implementation is a Program operating on Data concept. The Data (KBF) is created within Build-A-Board. The run-time software (deployed/implemented/installed/located) on the run-time target reads this data, displays the layout to the user, and then processes user actions based on what the user selects. The "Regular" Key Action is to create the down/up events as if a physical key was pressed. This is seen as a keystroke by the underlying application. There are other actions available, including opening a new layout (New KBF command) and running an arbitrary program (Exec command).

What are the project files? What should I open? What is PROJECT.TXT?

The project files are simple text files that describe in human readable form the layout & keyboard properties. They are an interim step towards a complete database of layouts. The zip format is just to compress & reduce disk space. If you see both a PROJECT.TXT and a zip, open the PROJECT.TXT, as this means the Project is "Open" (i.e. unzipped) and may have modifications that haven't been "zipped" up again (File | Close Project). We recommend you use the front-end display of layouts to get around the whole project file issue - just pick a layout, and go with it.

When I "F9 - Build" what am I creating? An EXE somewhere?

You are creating the KBF file (KeyBoard File). This is a singe file representation of the layout that can be used by the run-time software. Because it is now cross-platform, this is the "Data" part of the Program & Data concept (like a .DOC file contains the "document"). You "get" the keyboard you just created by loading the KBF in the run-time software. When you select a target platform, it also copies over install/run-time files - so theoretically you could take these over to the platform, install the run-time files, run the My-T-Soft binary/executable (e.g. MYTSOFT.EXE on windows) and then get the display / operation of the KEYBOARD.KBF (default KeyBoard File). For a Windows target, refer to the MSWIN32 folder (Shift-F11 to view) to see the "run-time" files - these are what gets deployed on a Windows system (and similarly for other platforms).

What is required for the target system? What does Run-time mean? How do I integrate it with my application?

Here is a quick run-down - refer below for further details, and use the Product Guide for even more details.

Create or Modify a layout in the builder.
Select Target in the Run-Time menu (e.g. Windows 32)
Build (& execute to test)
Install the Target (run-time) files on your deployment target
Run My-T-Soft at a system level, or at application start (Shell/Exec/etc.)
Use Developer's Kit Tools (or concepts) to move keyboard window on-screen when needed/off-screen when not
Use an iterative approach to get the custom keyboard layout integrated into your application
Here is a more technical overview

The approach to the user interface is to have the executable display a topmost window that presents a keyboard (or arbitrary button display) to the user. It handles input focus issues so any virtual keystrokes are seen as standard keystrokes to the application. This is the My-T-Soft program, sometimes referred to as the "Build-A-Board run-time". For example, on windows, when you run MYTSOFT.EXE it reads the KBF (KeyBoard File - KEYBOARD.KBF) and displays the layout as designed and built in Build-A-Board.
The run-time software is an EXE (or program/binary process based). As such, it should be running at a system level, or at application startup (see more below)
The user interface aspect is separated from the actions. All external Key Actions are handled by the MacroBat process (Macro Batch Processor). This is implemented as a separate process. So the 2 processes (My-T-Soft and MacroBat) must both be on the run-time target to read the Data (KBF file), display the layout to the user, and process the actions when a button is pressed. Note that with the CMD:EXEC any arbitrary process can be launched when the user initiates this action by pressing a button on the layout. New layouts can be opened with the CMD:NKBF command - a common approach for user control is to have a single button layout that opens the full layout, and then a minimize button that returns to the single button layout.
In general, we recommend you run the keyboard (e.g. MYTSOFT.EXE in Windows) at system start, or application start - then during the life of your application, you can control access with the "MoveWindowMTS" function/concept - move it off-screen to remove it from the user, move it on-screen to display it for the user at the X/Y location you want. This keeps the process running, and you don't have any shut-down or startup delays. If done at the system level, StartUp group is typical, and if handled in the application, a Shell or Exec type function is typical.
The most effective way to handle "on/off" is to move on-screen/off-screen. Using the New KBF (CMD:NKBF) the user can select different layouts. Refer to the MoveWindowMTS function (MOVEWMTS.EXE for windows, etc.) See the DEVKTDOC folder to open the Developer's Kit Documentation.

Download trial


Currently there are no reviews for this product. Share your opinion with others, be the first to write a review.

Add Your Review

Your Name:
Email Address:
Note: HTML is not translated! Your email address will not be shared with anyone.
Your Rating: 5
Your Name:
Your Email:
Friends Name:
Friends Email: