Below are categories, items and features of Iron that are planned but Not Yet Implemented.

Being a small team, it’s not practical to anticipate when these features will be implemented. We have so many ideas and tasks and demands on time that’s it difficult to know which parts of our Re-Imagined Workspace will get priority. As we get feedback, we adjust our schedule as well as our designs. So, the items below point in the direction we’re heading with Iron.

As we design and work on these new features, we definitely would like to have your input, your desires, your experience and knowledge to help guide us as we enhance Iron to become the best possible text editor. Please join our forum to make comments, suggestions and share your ideas.

Thanks much!

For me, the winning strategy in any start-up business is, ‘Think big but start small’. 

Carmen Busquets

Venezuelan pioneer luxury and fashion entrepreneur, co-founder of Net-a-Porter and CoutureLab.

Why no windows or pane docking system?

As with all the features mentioned in this document, the lack of a windows or pane docking system is about choices, mantras, timing and priorities.

In this case, we made a conscious choice about not using the operating system’s built in windowing or MDI environment for a number of cross-platform reasons as much as for esthetic reasons.

We’re implementing Iron’s graphics with the OpenGL library building our own widgets so the environment can be completely themed, consistent and devoid of operating system dullness. Like a video game, we want to keep you, the programmer, completely immersed in your work (with a touch of humor), deep in the environment, the feel and without interruption to one’s hard to attain programming zen.

We also want to avoid the standard, dull, 1984-look-and-feel which is rather plain and uninspiring. We also do not like having to use the mouse with small buttons, togs, thin grips and would rather have large, easy to see and easy to manipulate interactive elements. Spending time to carefully aim, select and drag tiny elements with the mouse is not our idea of fun or very productive.

For windows and panes, stretching, moving, docking and rearranging is an activity that’s seldom done. A programmer more typically arranges their environment, might have several setups they’d like to quickly choose amongst but its not a productive activity done all the time. Rather, its a modal activity. So that’s how we plan to implement the docking system.

Instead of devoting much needed screen space to grips and UI elements that are small and not much used, we want to make the docking system a mode where the user presses a function key and large manipulators appear, fade in or animate and then go away once stretching, sizing and whatnot are completed. We also want the manipulator to be 3D and in-theme, for example with Iron’s steampunk heritage, something modeled with brass, glass and steam. In other words, make it fun, not 1984 dull.

As a part of this design, docking layouts can be saved and a graphical representation named and presented by the menu system (and not in 2D).

And then there’s the complexity of tearing off a file, a pane (or set of panes) to their own window – mostly so odd monitor configurations can be accommodated or so developers can Alt-Tab between windows each of which can have their own layout. The complexity comes in what level of connection or cooperation is required between the multiple sets of windows? Are they separate sessions of Iron or one session with multiple windows? We also have future cooperative and team features on the drawing board to take into account.

So, at the very earliest time in Iron’s development, we opted to provide a fixed number of panes with a fixed number of layouts and deal with the complexity of the design and implementation of the docking system at a later date. It’s likely we’ll add the modal organizing of pane layouts (any number of panes) within a single session and be able to save and recall multiple layouts and save tearing off panes to a separate window until later when the cooperative capabilities come online.


How come there are no scroll bars?

Well, this comes down to several conscious choices and taking note that Iron’s native editing mode which is Iron Professional Mode with sticky selections and virtual space editing (VSE).

One important design decision for Iron is that the primary caret always remains visible on-screen. You can’t move it off-screen which prevents accidentally making edits to the source code when you can’t see it. This is different than other editors.

** The primary caret itself is the vertical and horizontal scroll bar in VSE mode. **

In other words, as you move the caret up, down, left and right with the arrow keys or dragging the caret with the mouse, the text in the text view will automatically scroll to keep the caret on-screen and within the caret box.

The mouse wheel can be used to scroll the text vertically in the text view or in the Minimap. “Scrolling” in Iron moves text relative to the caret. In other words, the primary caret will move its location within the file to stay at the same location on the screen as the text scrolls underneath it. This is also different than other editors.

And then the Minimap functions as a large, informative scroll bar. Clicking and dragging in the Minimap is the same as clicking and dragging the caret around in the text view. As the caret is dragged vertically outside the caret box, the text will automatically scroll to keep the primary caret on-screen and inside the caret box at all times. This is different than minimaps in other editors.

Additionally, you can select text in the Minimap. That’s different. You just can’t scroll horizontally.

With the recent advent of Traditional Mode, stream selections and particularly non-virtual space editing in Iron, there are ramifications of using the primary caret as the scroll bar. The primary caret can’t move into virtual space beyond the end of its current line of text. This means there’s a limit on how far text can be scrolled to the left and it depends on the length of current line.

So, if there’s a longer neighboring line of text, it may stretch off-screen to the right and you can’t scroll it into view unless you move the caret to that line. Well, that could become rather frustrating for non-VSE traditionalist.

Our recommendation is to virtual space editing mode — and not just due to this scrolling quirk but rather for many other proficiency reasons.

Though it would not solve this particular scrolling quirk in non-VSE mode, we may need to implement scroll bars as an option – just to appease traditionalists. However, they still won’t function like other scroll bars and allow the primary caret be off-screen by miles.


Will there be a sidebar, workspace or project pane in Iron?

Absolutely yes.

The reality of any programmer is that they are coding a project which consists, invariably, of multiple source code and resource files. These text files will likely be located in various places — different directories, drives, removable media and network locations. A project pane is a ubiquitous organizational tool for the software developer. It’s really damn handy. Being able to switch between projects, quickly, is also another necessity for the developer.

There are several reasons why Iron doesn’t have a project pane just yet. First, one can rely on the operating system’s File Open dialog, dragging and dropping from files the Windows Explorer and loading them via the Command Palette. The Command Palette, once the Directory Search Path is setup, is easiest and quickest for loading a file though the directory search path is a pathetic mechanism, not at all convenient, is awful for switching between projects and hence offers nothing in terms of being of organizational value.

Second, we wanted, again, to develop an in-theme widget and not rely on the operating systems folder tree look and feel and limitations. Our desire is to incorporate 3D game-like elements, not just for fun but also to be informative. The project pane as an organizational tool can, with graphical elements, offer alternative and potentially better views into a project than a simple folder tree. Is it useful to view a project in 3D? Sure and once that’s possible, can that 3D view be manipulated (yeah, with a mouse) and the project itself be reorganized? In other words, there’s a lot of potential to consider in the design of the project pane.

And thirdly, we’ve been trying out several toolbar and menu designs and implementations. We’d like to leverage the “menu system” so it can be used for the project pane. And if the project pane can manipulate its elements, we’d like the menu system to take that advantage so the user can customize the menu layout in exactly the same fashion. We’d also like the menu system to be used for the file tabs system as well — which interacts with the non-existent docking system.

We’re just about to start in on the project pane. As Iron’s author, I can’t wait as I’d like to have this to organize my own projects. The convenience will be wonderful.


Will there be user-definable context menus?


Iron’s history with toolbars and menu systems is long. The very first rendition of Iron had a standard Windows menu mostly because desktop applications simply have a menu, its tradition, not necessarily a design choice or requirement.

Yeah. Well, our design choice became: no menus and no dialogs.

This was a backlash of having lived in the drill-down world of Visual Studio’s massive menu system and gargantua death-by-dialog labyrinthine maze. The norm in IDE’s and text editors was (and often is) about menus and stacks of toolbars and indecipherable icons. Menus and dialogs just sucked the joy out programming.

And for us, if we were going to have a toolbar in Iron, it’ll be small, mostly out of the way, and it better be colorful, responsive, animated and cool – not mind-numbingly dull. Please.

The simple toolbar design we implemented turned out to be cool looking but impractical. There are, in fact, just too many settings that need to be accessible and menus get heavy real quick. In other words, it’s not really possible to keep a cool looking toolbar small, simple and clean.

So we opted to change settings just using the Command Palette. That, however, doesn’t work either. There are, indeed, so many things to tailor, it becomes untenable to expect new users to interact entirely via the Command Palette. There’s no simple means of discovery. A menu system is what newbies got to first.

So, a menu system winds up being a plus — folks can find what they need (with enough drill-down practice). The menu system is a great crutch until the Command Palette becomes more convenient with experience.

The second menu system was a crashing nightmare and didn’t get along well with the rest of Iron’s highly threaded environment. So, that was scrapped and a third menu system is now in play. We have high hopes for what it can accomplish in terms of 3D interactivity.

The main menu can be hidden thus no screen space need be devoted to a UI widget that an experienced programmer won’t often use. Experienced programmers will rely more context-aware key bindings and the Command Palette.

For the drill-down expert, we added the Menu Recall Last feature. Click the left mouse while holding down the Ctrl key and the mouse cursor will return to hovering over the last drop-down menu item selected. That’s really convenient. Soon, we’ll add choosing menu items and not dismissing the drop-down menu so more menu items can be quickly selected.

We can’t solve the drill-down problem but we can make it more convenient to work with.

So, yes, there will be user-definable context menus, traditional in form at first and then cool like a video game front-end. You’ll be able to right-click on all over the place.


Given that Iron supports customizing of the menus, the key bindings, scopes and colors via macros, how come there are no traditional setup files like an INI or .rc file?

Good question. Long answer coming…

First, Iron has had a text config file that functioned as a simple setup file. Too simple really. Iron is written in Slang (a proprietary computer language) which allows any global variable to be accessed via the command line or a config file which is automatically processed at application startup. We’re phasing this system out in favor of using Zinc formatted setup files. Zinc is Iron’s internal language used for menu and key binding definitions.

Setup files are amazingly complex. Our intent via the Zinc syntax is to provide more than just setting internal values and calling of built-in actions. There’s need for more logic a.k.a. If-statements. There’s more complexity in tailoring a text editor than most folks realize and simple INI or .rc files aren’t quite sufficient.

The real complexity comes about with setup file precedence order and processing. For example, some settings are appropriate depending on the computer language of the files loaded, of the theme in use, of the platform or the international language desired and more. In reality, there’s many, many setup files involved, no just one. Not even close.

This all means that there are default setup files and then user-configurable setup files. Which one has precedence? Changing a default setting in a factory default file isn’t ideal but layering a new setting by simply processing a user-defined setup file isn’t sufficient either.

How are settings changed on-the-fly, say, via the menu system preserved? Setup files, then, need to be saved on behalf of the user and still feather well with the precedence order of all the other setup files.

Suffice it to say, in the end, organizing and managing and orchestrating setup files and user settings is not that simple.

We’re about to tackle it in phases. Stay tuned to a Zinc formatted file near you (or rather, many Zinc files near you).


Will Iron support user-definable lexers and syntax highlighting?


At the moment, Iron has one built-in syntax for Slang, Iron’s implementation language. So, there is syntax highlighting, only its for just for the Slang language, Iron Zinc files though it can be used by files with C/C++ file name extensions.

Not yet released are user-definable lexer definitions written in the Zinc file format. This allows users the ability to define keywords and other attributes about any computer language. Each element can be assigned a selector which in turn references a scope. Scopes are how colors (and eventually other theme attributes) are associated with syntax-highlighting.

They’re almost here. Iron should support 40+ languages very soon and be assignable to any text file regardless of file name extension.


Will Iron have auto-complete?

Yes. Once user-defined lexers become available.


Will Iron be localized for audio?

Yes, that’s our dream — to have a sultry Swedish or Norwegian voice coyly inform me that “That file can’t be found” or rather “Den filen kan inte hittas, älskling.”

Perhaps Thor is your preference. Anyone know Chris Hemsworth?


Will Iron support language-sensitive snippets?

Yes, someday.


Will Iron have a record and playback feature?

Yes, it’s in the hopper.

By design, all of Iron’s user input is processed through the keymap file definitions. Internally, Iron records keyboard and mouse presses and releases and matches combinations to key bindings. That mechanism is primed for recording named, storeable sequences.

Some of the difficulty and concerns is how far to take the recording. We’d like to see editing sessions replayable in the form of interactive tutorials. That, however, involves recording mouse movement, managing context checks, mode and settings changes, etc. Uncertain, too, is whether to record keystrokes, combos or command sequences or some combination — and again are does context validation get recorded or not.

Suffice it to say, we will implement a simple recording and playback feature at some point.


Does Iron have a build system?

Yes and no.

Iron has had a primitive build system for a long time. I was based too much on traditional make files and wound up being rather clunky. It will never be ready for prime time.

There had been high hopes that Iron and Slang would have a tight pairing thus providing continuous, minimal compilation. C++ and other language compilers and linkers are horrendously slow. True when Iron was conceived — and still true today.

Iron’s internal language called Zinc is a subset of a new, much large language called Copper. Zinc, as implemented in Iron, compiles continuously, building and resolving as-you-type and faster than you can reach for the Build button. This whole topic on compiler and IDE design and how these tools are stuck and mired in old software idioms deserves its own book.

Iron will have a build system, someday, based on Zinc that will provide minimal building, ideally continuous and easy to configure and move cross-platform. Build systems, as we all know, can be wildly complex. Not sure that’s necessary.

An interim step will be to provide execution of command line utilities (Iron does that now) and capturing of tool output so it you have Cmake files or a standalone build process, Iron can engage it and replay its output to a build pane. That’s what Iron’s current, cumbersome build system does now.

Whether Iron will provide a Python environment internally is uncertain. LUA support, not likely.


Will Iron have SCM (source code management) integration?


Though not documented and marginally sufficient, Iron supports Perforce. In other words, Iron will automatically checkout files from Perforce via batch files. There are no checkin utilities.

We do hope to add GitHub, SVN, RCS and more Perforce integration. What other SCM systems should we consider? Please let us know in the forum at:

One thing about integration of SCM tools (a trend we hope to avoid) is providing administrative facilities via Iron’s interface. Our position is that SCM tools are so varied and complex, especially administrative functions, that the user is better served if they go to the SCM tool and use the interface designed for that purpose.

What we do want to integrate are simple and convenient means to checking out source code and checking in source code, optionally in bulk, with comments. We’d also like our project pane and file tabs to present the SCM status and allow initial checkin of new source code files.

Whether Iron will provide or integrate a merging tool is uncertain though we recognize that merging in a team project is reality and that it is about text manipulation. Not sure, we might be able to do it in a more interesting fashion. Our suggestion at this time is, again, use the SCM tool that best meets your needs.

At present, Iron does allow the locking and unlocking of files from the File drop-down menu. We don’t recommend doing this though it may aid in interaction with your SCM tool. It may also totally screw you up.


Will Iron have regex (regular expression) search capability?


We’ll likely use the Oniguruma regex library. As Iron partitions lines of text in memory (actually it tokenizes heavily), we’re not certain about multi-line pattern searches which are much less commonly used in practice. We may need multi-line regex searching for improved syntax highlighting and smart navigational needs.

We’ll also have searching in reverse soon. Yes, I’m chuckling, too.

And the Command Palette will support fuzzy searching or fuzzy pattern matching with a weighting system as that is much more convenient often times than regular expression searches.


There’s no Find-in-Files dialog.

Iron’s Find-in-Files (FIF) utility works via the Command Palette, via single-line selections and through Quick (Ctrl+Shift+F) access (the search string is picked up from text the primary caret is over or near). It’s really fast.

The Directory Search Path (Ctrl+Alt+D) must be setup and the fif_ext variable set as well. There is also the fif_case_sensitive toggle which is defaulted to false for case insensitive searches.

A FIF search generates an iron.results file which, in a multi-pane layout, is very convenient for viewing the found text in a neighboring pane. Its quick and easy to navigate amongst many files using the blue Results pane.

In keeping with Iron’s design goal of not dialoging the programmer to death and to forego traditional interfaces if they’re not needed, we haven’t implemented a traditional Find-in-Files dialog. Doesn’t seem to be much of a need if you use the keyboard, avoid the mouse and are comfortable with the Command Palette.

With that said, for beginners and those coming from other editors and if popularly demanded, we may yet implement a traditional Find-in-Files dialog. It’s low down in the hopper.


There’s no Find-and-Replace dialog.

As for a traditional Find-and-Replace dialog, which is often an extension of the Find-in-Files dialog, many of the same design goals apply. See above. It is also low in the hopper.

Our thinking for Find-and-Replace is to take a slightly different approach: Multi-Selection.

Find-and-Replace within a single file is accomplished with Multi-Selection. Simply search for all occurrences of a text pattern via the Command Palette, a single-line selection or via the Quick option (the search pattern is taken from text under or near the primary caret) to form a latched multiple selection. Then just type your changes. That’s find and replace using Multi-Selection without a dialog and no mouse.

A huge advantage is you can search piecemeal with Iron’s Multi-Selection feature, skipping some matched text and keeping other matched instances — which you can’t do from a dialog.

And then, after the fact, you can review each change simply using the Escape key ESC. And you can make piecemeal corrections by unlatching the multi-selection, make the change then continue canceling selections one at a time.

So, if you get it, Multi-Selection is much more capable, powerful and convenient than the traditional Find-and-Replace dialog. Hence, that particular dialog winds up low in the priority hopper.

One gotcha in Traditional Mode where Iron Profession Mode and Sticky Selections has an advantage:  As you type in Iron Pro mode, selected text is not deleted. In other words, with Sticky Selections, you can insert new characters, delete characters, extend the latched selections to the end-of-the-line, for example, and more. In this way, Multi-Selections and Sticky Selections gives you more options and editing possibilities than a traditional mode Find-and-Replace dialog.

Using Multi-Selection for Find-and-Replace across multiple files will soon be possible. Stay tuned. You’ll rock this!

Multi-Selection is Iron’s power-feature. No dialog required.