Epsilon Editor


You Deserve More


There are many programmer's editors available. Why should you choose Epsilon? Why not settle for the "free" editor that comes with your compiler, or some lesser programmer's editor, or even try to use a word processor to edit your programs? We'll try to explain why we think you should choose Epsilon instead.

If you decided to build a house, you'd first select the right tools. It's the same with software. Epsilon is like a toolbox full of premium tools you can use to get your job done quickly, easily, and with minimum fuss. Unlike some other editors, you won't outgrow it.



Consider all the different ways Epsilon has for getting to the right place in a file. Any editor has commands for moving by characters, lines, or words. But does your editor know how to move by sentences? Paragraphs? Can it skip over a parenthesized expression in your C++ program, counting matching parentheses, or jump to the #if statement that matches a particular #endif? Epsilon can.

Suppose you're looking at a subroutine call in your C source file. The subroutine happens to be defined in another file. With Epsilon, you can press a key and jump instantly to the definition of the subroutine. Epsilon automatically loads the appropriate file and goes right to the definition. Press another key to return to the original file. This makes it easy to work on large projects; jump from function to function with simple keystrokes.

Epsilon also has a bookmark mechanism that lets you say "remember this place". Later, press a key and Epsilon goes back there instantly. Epsilon can remember up to 36 bookmarks at once, and can even remember them from one session to the next.

(By the way, each of the screen shots you'll see in this document are linked to higher-resolution versions of the same image. If you'd like to view any of these screen images in more detail, just follow the link.)


Don't know where in the file you need to be? Try Epsilon's searching commands. You can give Epsilon complicated regular-expression patterns, and its highly optimized searching engine will locate matches in no time. Epsilon also searches (and replaces) with or without case folding, restricts matches to whole words, matches patterns that span multiple lines, searches incrementally as you type a pattern, and much more.


Epsilon's built-in grep command searches for text in multiple files. Give it some text to search for (or a pattern, with all the same options as above available) and a file name with wild cards, and Epsilon constructs a list of lines containing the text, so you can see all the matches at once. Select one, press a key, and Epsilon jumps to the file and line that matched (even if you've changed other parts of the file since the search). Jump from match to match as needed, with simple keystrokes. Epsilon uses an enhanced syntax for file patterns so you can easily tell it to search files meeting certain conditions: for example, search in all .c or .h files whose names start with a digit, in either the C:\NewProject hierarchy or anywhere on drives D or E.

Now, take a look at Epsilon's file comparing commands. Epsilon has a built-in "diff" utility that compares two files and lists the lines that have changed. Epsilon can show the changes with color coding, mark the changes with #ifdef/#endif lines, or generate a traditional all-text summary of changes. But that's not all--it also has an interactive change finder, so you can conveniently compare two small blocks of text and go right to the first characters that differ. Plus another compare function that looks through word lists or similar things, and prepares lists of items in one list but not the other, or in both lists. Many editors have no built-in comparison function; Epsilon has five, so you can always use the right tool for the job.

Carefully Thought Out


Consider Epsilon's mouse support. Of course, you can use the mouse to select text or resize windows. And you can drag the text to move or copy it. But many programs do this. Where Epsilon differs is in the details. Throughout the editor, you'll find that Epsilon just does it better.

We designed the mouse to be as non-intrusive as possible, so that when you're not using the mouse, you won't notice it's there. Epsilon automatically hides the mouse cursor when you're typing, so it doesn't get in your way.

Epsilon provides a menu bar that you can customize by editing a simple text file. (Epsilon automatically adds the correct keyboard equivalents for each menu command, even if you've rearranged the keyboard -- which, by the way, is extremely easy to do in Epsilon.) You'll find the commands for Epsilon's context menu (on the right mouse button) in the same place, and just as easy to customize.

You can also customize the tool bar that Epsilon provides under Windows 95 and Windows NT. And if you just want as much room as possible for your text, you'll be glad to learn that the menu bar and tool bar are both optional--you can toggle them on and off as you wish.

Many editors have an undo command to undo the last change you made. Some even let you undo the last several changes you've made. But does your current editor let you undo hundreds of operations, the way Epsilon does? Epsilon's undo key lets you undo any sequence of changes, one at a time, and the redo key enables you to undo your undo's. So you're free to casually use the undo facility. And Epsilon remembers undo information even when you write your file to disk. Some other editors discard all undo information when you save a file. Not very handy: you make some changes, save, then try to compile. "47 errors!?" Too bad -- hope you had a backup.


Consider Epsilon's completion mechanism. If you begin typing a file name, Epsilon can fill in the rest of the name for you, or show you all the files that start with that name. A lot of editors can do that much. But Epsilon isn't restricted to completing just file names. It does the same thing with commands, variables, tags, buffers, screen sizes, and so forth. Epsilon's completion mechanism is totally general, so it works everywhere. And it's extensible, too: if you use Epsilon's powerful EEL language to write new commands, those commands can use completion just like built-in ones. They'll also automatically get the benefits of Epsilon's command history: Epsilon remembers your previous responses to all prompts, even from one session to the next, to save you typing.


Now, let's say you're trying to select a file (or a command, or a variable...) and you can't remember its name, but you think the name "exit" occurs in it. Was that file "sysexit.cpp" or "jhexit.c" or possibly ...? With other editors, you get a list of files and then page through the list looking for the file you want. Not with Epsilon. When Epsilon shows you a list like this, you can search it like any other text, or use any other Epsilon commands on it.

This kind of generality makes it easy to do all kinds of tasks we've never even thought of. Say you need to know how many subroutines or variables in your 100 megabyte project have the same name as one of the 10,000 files on your disk? No problem with Epsilon. The tagging package gives you the list of subroutines and variables in two keystrokes. Save it in a buffer the same way you'd preserve any text. There are lots of ways to get a list of files (and if you want to only look at files in a certain hierarchy, or on drives G:, H:, and I:, or within a subdirectory whose name matches a pattern, you can do that too). Next, use Epsilon's powerful and very fast "regular expression" replacing to remove the directory names and extensions. Then just two more simple commands give you the list of functions that match file names. Epsilon makes bizarre tasks reasonable, and simple tasks easy.



Epsilon has a variety of features to make programming tasks easier:

Epsilon's sophisticated C/C++/Java indenting recognizes keywords and language constructs, automatically indenting to the right level (and making it easy to spot a misplaced brace).

Smart paste automatically reindents code as you move it from place to place.

Epsilon has commands to move forward or back by parentheses, square brackets, or #if/#endif pairs. All these commands understand nesting rules and skip over nested pairs.

Epsilon for Windows connects to WinHelp files, so you can quickly look up a keyword or the parameters for an API call.

Epsilon's concurrent process buffer lets you run command-line programs interactively in an Epsilon buffer, so you can use the full power of Epsilon to prepare input or modify output.

Compile from Epsilon, and the editor will intercept your compiler's error messages. Instantly jump to any syntax errors with the touch of a key.


Customizable syntax highlighting for C, C++, Java, HTML and TeX makes your code easier to read. Plus Epsilon automatically highlights matching delimiters when you move to them, making it easy to read complicated parenthesized expressions.

Type an ftp file name at a file prompt and Epsilon for Windows 95/NT will asynchronously retrieve the file via ftp from any computer on the Internet. Also edit remote directories using dired, save files, run a Telnet session, retrieve the HTML text of web pages, and more.

Sometimes programmers need to look at unusual files: binary files, very big files, odd data files. Epsilon was designed without the limits of other editors, so it can handle these kinds of jobs, as well as ordinary files. For example, with Epsilon, lines can be as long as you like. That's important when you're editing unusual text. Many other editors have a maximum line length of 256 or 512 characters, and can't edit any files with longer lines. Or they always strip null characters or line terminating characters when you load a file.


With Epsilon, you don't have to switch to another editor when you've got unusual editing tasks: Epsilon can handle them. Epsilon automatically recognizes binary files, Mac files, and Unix files. You can even use Epsilon to edit executable files. And Epsilon can either horizontally scroll long lines or wrap them for display purposes--that's important when you edit a big file that's all on one line. Many other editors only have horizontal scrolling.


Since your editor is so centrally important, it must free you to work the way you feel comfortable. Customize Epsilon a little or a lot--it's up to you.

Epsilon includes built-in keyboard configurations for Emacs and Brief, and can switch between them effortlessly. Plus you can interactively rearrange the keyboard at any time--not just at installation. The powerful help system keeps track of any rearrangements you make. Suppose you've told Epsilon you want Ctrl- to go to the next match of your search text. Ask Epsilon to list all commands related to searching, and it'll tell you, among other things, that you can press Ctrl- to go to the next match. When you modify the keyboard arrangement, Epsilon automatically reflects this in its help text and in the menu bar. Other editors often display "canned text" when you ask for help; Epsilon generates its help text dynamically.

Epsilon has dozens of variables you can set to change all sorts of aspects of the editor, to make it work just the way you want it. For example, Epsilon has a command that lets you change the screen appearance of the editor to make it resemble one of several other editors. The command moves scroll bars and menu bars around, displays line and column information in different ways, changes colors, and so forth. But it doesn't operate by switching Epsilon to one of a certain number of fixed settings--it just sets some variables. The advantage? Well, perhaps you want the current line and column in the lower right, on the border of each window. No problem. Want to add the time? Fine. Don't want the seconds, just the minutes? Done. Maybe today you'd like Epsilon to display your text on all the lines of the screen, with no distracting borders or status lines? You've got it. Throughout the editor, Epsilon gives you this kind of control, so you can set it up exactly as you like.


Epsilon masquerades as Brief.


Epsilon masquerades as the DOS/QBASIC Editor.


Epsilon without borders.


Automate frequent editing tasks by defining keyboard macros. These record-as-you-go macros are convenient when you don't need the power of a full-blown extension language program. You can define as many as you want, name them, and attach them to keys. Some other editors, if they even have macros, only permit one at a time. If you want to use another macro, you have to load it from disk first.

For more sophisticated needs, Epsilon has an advanced C-like extension language named EEL. No one comes close to the Epsilon Extension Language when it comes to speed and expressive power. Other editors say they have C-like extension languages. But how many offer a full set of data types including numbers, arrays, strings, pointers, structures and unions? And Epsilon's data type facility is fully recursive, so you can have, for example, an array of pointers to structures.

To these data types familiar to C programmers, EEL adds others designed to make writing editor extensions easy. For example, you can define variables that hold a different value in each window, or in each text buffer. Epsilon automatically takes care of replicating the value when you make a new window. It's this kind of attention to detail that makes EEL so powerful.


EEL is a language designed specifically for writing powerful editor extensions. Take a look at your current editor. How many of its commands were written using its extension language? With many editors, most commands are built-in and unchangeable, and only a handful are written in the editor's extension language. Why? Because other editors' languages are just too wimpy and slow. Not Epsilon--every command in Epsilon is written in our lightning-fast EEL extension language. That gives Epsilon exceptional flexibility. And you get EEL source code for all the commands. With Epsilon, if a command doesn't operate exactly the way you want it to--if you want to make it do just one more thing -- you can. EEL even includes support for calling DLL's (or for calling interrupts, in Epsilon for DOS) so Epsilon can talk to other programs.

You probably won't need to learn EEL and write your own editor commands. But isn't it nice to know that you could? And you benefit from the power of EEL in another very important way: Epsilon users like to share their extensions with others through our Internet anonymous FTP site. Other Epsilon users have sent in many wonderful and amazing extensions ready for you to use. Commands that extend the editor to work with new languages, connect to other programs, check the spelling of your text, extract the format of database files -- all kinds of things.

Epsilon Editor...$350

Home || Shopping Cart || Site Map || Newsletter/Blog
Search HALLoGRAM || Request More Information
CALL TOLL FREE 1-866-340-3404

14,500+ PRODUCTS:

Order Epsilon Editor

  • Editors

  • MS-Access
  • ActiveX/OCX Controls
  • C/C++
  • Clipper
  • dBASE
  • Delphi
  • FoxPro/VFP
  • Java
  • Macintosh
  • Oracle
  • Paradox
  • PowerBuilder
  • Visual Basic
  • Visual Objects

  • Keystone Training Videos

  • Copyright 2000 HALLoGRAM Publishing, Aurora CO. All Rights Reserved
    All products mentioned in this site are trademarks of their respective owners
    Prices are subject to change without notice