UltraEdit plugins
Plugins
The UltraEdit plugin system allows you to extend and enhance UltraEdit’s capabilities using JavaScript without modifying the core application. This powerful system enables developers to create custom tools, automate tasks, and add new functionality that integrates seamlessly with UltraEdit’s interface.
Plugin SDK first added in UE 2025.0.
What are UltraEdit Plugins?
Plugins are modular units of code that add specific features or functionalities to UltraEdit. They consist of JavaScript files that can interact with UltraEdit’s core features through a standardized API. Plugins can be accessed through the ribbon, keyboard shortcuts, command palette, menus, and toolbars.
Benefits of the Plugin System
- Extensibility: Add custom functionality without altering UltraEdit’s core code
- Modularity: Easy to manage, update, and maintain individual plugins
- Community: Share and use plugins created by other developers
- Integration: Seamless access through UltraEdit’s existing interface elements
- Automation: Automate repetitive tasks and workflows
Plugin Wizard
UltraEdit includes a built-in Plugin Wizard that helps you create new plugins quickly and easily.
Using the Plugin Wizard
Plugin Type Selection
- Select between Function Plugin or Applet Plugin using radio buttons.
- Function Plugin: Creates traditional command-based plugins
- Applet Plugin: Creates dockable window plugins with HTML interfaces
Plugin Configuration
Configure your plugin with the following fields:
| Common Fields (Both Plugin Types) | |
|---|---|
| Name | Internal name of the plugin |
| Display Name | Name displayed in ribbons, toolbars, command palette, key mapping |
| Short Description | Brief description of the plugin |
| Long Description | Detailed description of the plugin |
| Light Theme Icon | Icon used for light themes |
| Dark Theme Icon | Icon used for dark themes |
| Hotkey | Keyboard shortcut assignment |
| Chord | Secondary keystroke assignment |
| Additional Fields (Applet Plugins Only) | |
|---|---|
| Index Name | Specifies the file that the dockable window’s WebView2 control navigates to during initialization. Defaults to index.html. |
| Initial Dock Side | Specifies where the window is docked initially. Options: Top, Bottom, Left, Right, or Float. |
Completion
Note: The Plugin Wizard creates user plugins in %APPDATA%\IDMComp\UltraEdit\userplugins\<plugin-name>
Plugin Manager
The Plugin Manager provides a centralized interface for managing all your plugins.
Plugin Manager Features
Commands can be accessed through the right-click context menu:
- Install/Uninstall: Manage plugin availability
- Enable/Disable: Control which plugins are active without removing them
- Delete: Remove user-created plugins permanently
How Plugin Installation Works
Application Plugins: Pre-installed with UltraEdit in <installation directory>\plugins
User Plugins: Created in %APPDATA%\IDMComp\UltraEdit\userplugins
Installation Process: Copies plugins from userplugins to the active plugins directory %APPDATA%\IDMComp\UltraEdit\plugins
Plugin Management Rules
- User-created plugins: Can be installed, uninstalled, enabled, disabled, and deleted
- Application-installed plugins: Can be installed, uninstalled, enabled and disabled, but cannot be deleted
- Active plugins: Located in %APPDATA%\IDMComp\UltraEdit\plugins are loaded by UltraEdit
Creating a Plugin Manually
The Manifest File
Users can create plugins manually if preferred.Every plugin requires a manifest.json file that describes the plugin to UltraEdit. Here’s the structure:
JSON
{
“name”: “YourPluginName”,
“display name”: “Your Plugin Display Name”,
“short description”: “Brief description of what your plugin does”,
“long description”: “Detailed description of plugin functionality”,
“version”: “1.0.0”,
“script name”: “yourscript.js”,
“guid”: “unique-identifier-here”,
“icon”: “plugin-icon.png”,
“icon-light”: “plugin-icon-light.png”,
“icon-dark”: “plugin-icon-dark.png”
}
| Key Fields | |
|---|---|
| Name | Internal name for the plugin |
| Display Name | Name shown in UltraEdit's interface |
| Version | Current version number |
| Script Name | Name of the main JavaScript file |
| GUID | Globally unique identifier for your plugin |
| Icon | Default icon file (optional) |
| Icon-light | Icon used for light themes (optional) |
| Icon-dark | Icon used for dark themes (optional) |
The JavaScript File
The JavaScript file contains the plugin’s functionality. All code should be:
- Legal JavaScript compatible with Microsoft’s WebView2 component
- Encapsulated in functions – no executable code outside functions except global variables
- UTF-16 LE format
Required Functions
Every plugin must include an OnInit function that:
- Registers the plugin’s commands
- Returns plugin information in JSON format
- Calls UltraEdit.processPIOnInit() with the command data
Basic Plugin Structure
JavaScript
function OnInit() {
UltraEdit.processPIOnInit(`{
“guid”: “your-plugin-guid”,
“CommandName”: {
“type”: “Execute”,
“display name”: “Command Display Name”,
“short description”: “What this command does”,
“long description”: “Detailed description of command”,
“icon”: “command-icon.png”,
“icon-light”: “command-icon-light.png”,
“icon-dark”: “command-icon-dark.png”,
“hotkey”: “Alt+Ctrl+L”,
“chord”: “”
}
}`);
}
function CommandName() {
//
Your command logic here
UltraEdit.outputWindow.write(“Hello from your plugin!”);
}
Command Types and Properties
Function Commands
Function plugins or “Execute” commands can be triggered through:
- Ribbon buttons (Advanced tab, Plugin panel)
- Keyboard shortcuts (configurable in Key Mapping)
- Command palette
- Menus and toolbars
Applet Commands
Applet plugins or “GUIDockable” commands use UltraEdit’s dockable window architecture to create a new dockable window with a Microsoft WebView2 control to run applets. Triggering the command in the following ways will show/hide the window:
- Ribbon buttons (Advanced tab, Plugin panel)
- Keyboard shortcuts (configurable in Key Mapping)
- Command palette
- Menus and toolbars
Command Properties
| Type | "Execute" represents a function plugin with one or more commands “GUIDockable” represents an applet plugin with a dockable window |
| Display Name | Text shown in interface |
| Short Description | Brief explanation of command |
| Long Description | Detailed explanation of command |
| Icon | Command-specific icon (falls back to plugin default) |
| Icon-light | Icon used for light themes (optional) |
| Icon-dark | Icon used for dark themes (optional) |
| Hotkey | Default keyboard shortcut (optional) |
| Chord | Secondary keystroke for command activation (optional) |
| Index name | Applet plugin only - Specifies the file that the dockable window’s WebView2 control navigates to during initialization. |
| Initial dock side | Applet plugin only - Specifies where the window is docked initially. Options: Top, Bottom, Left, Right, or Float. |
Plugin Initialization Process
When UltraEdit starts:
- Scans the plugins directory
- Reads each manifest.json file
- Checks for existing config.json files
- Calls OnInit if config is missing or version changed
- Loads plugin commands into memory
- Makes commands available through the interface
Config File Generation
After first run, UltraEdit creates a config.json file in each plugin folder containing:
- Command information for quick loading
- Hotkey and chord configurations
- Version tracking
Accessing Plugin API
Plugins have access to UltraEdit’s JavaScript scripting API, which allows interaction with:
- Document content – Read, modify, and manipulate text
- File operations – Open, save, create files
- Output window – Display messages and results
- User interface – Access various UI elements
- Application settings – Read configuration values
Including Additional Scripts
You can modularize your plugin by including additional JavaScript files:
JavaScript
// include <path-or-filename>
Additional script files should be located in the plugin directory or subdirectories.
Example: “Hello World” Function Plugin
Manifest (manifest.json)
JSON
{
“Name”: “HelloWorld”,
“Display Name”: “Hello World Plugin”,
“Short Description”: “Simple greeting plugin”,
“Long Description”: “Displays a Hello World message”,
“Version”: “1.0.0”,
“Script Name”: “hello.js”,
“GUID”: “12345678-1234-1234-1234-123456789012”,
“Icon”: “”
}
Script (hello.js)
JavaScript
function OnInit() {
UltraEdit.processPIOnInit(`{
“GUID”: “12345678-1234-1234-1234-123456789012”,
“Test”: {
“Type”: “Execute”,
“Display Name”: “Say Hello”,
“Short Description”: “Display Hello World message”,
“Icon”: “”,
“Hotkey”: “Alt+Ctrl+L”,
“Chord”: “”
}
}`);
}
function Test() {
UltraEdit.outputWindow.write(“Hello World!”);
}
Installing and Using Plugins
Installation
- Create a folder in %APPDATA%\IDMComp\UltraEdit\Plugins
- Place your manifest.json and JavaScript files in the folder
- Restart UltraEdit
- Your plugin will appear in the Advanced ribbon tab
NOTE: Only plugins that exist in either <installation directory>\plugins or %APPDATA%\IDMComp\UltraEdit\userplugins will actually appear in the UltraEdit interface.
Accessing Plugin Commands
- Ribbon: Advanced tab → Plugin panel
- Keyboard: Use assigned hotkeys and chords
- Command Palette: Search for plugin commands
- Key Mapping: Assign custom shortcuts in Configuration
Best Practices
Development Guidelines
- Test thoroughly before distribution
- Use descriptive names for commands and functions
- Handle errors gracefully with try-catch blocks
- Document your code for maintainability
- Follow JavaScript best practices for performance
Security Considerations
- Plugins run with application-level access
- Enterprise users can disable plugins through system locks
- Validate input to prevent security issues
- Be mindful of file system access
Performance Tips
- Cache frequently used data when appropriate
- Avoid blocking operations in command functions
- Use efficient algorithms for text processing
Troubleshooting
Common Issues
- Plugin not appearing: Check manifest.json syntax and file encoding
- Commands not working: Verify function names match command objects
- Hotkeys not responding: Check for conflicts in Key Mapping
- Script errors: Use UltraEdit’s output window for debugging
File Format Requirements
- All JavaScript and JSON files must be UTF-16 LE format
- Use proper JSON syntax in manifest files
- Ensure GUID uniqueness across plugins
Advanced Features
Multiple Commands
A single plugin can export multiple commands by adding more command objects to the OnInit JSON structure.
Icon Customization
- Provide plugin-wide icons in the manifest
- Override with command-specific icons
- Support standard image formats
Integration Points – Applet Plugins
Applet plugins integrate with UltraEdit’s existing infrastructure and events. Currently supported events:
- apiInitialization event
One-time event on plugin instantiation during application startup and plugin loading, indicates that all internal plugin API objects are fully created and initialized.
- themeChange event
Occurs when the application theme is changed. Plugins should handle this event notification and update any plugin UI elements as needed using the UltraEdit.theme object for color information. (See default Wizard Applet plugin for a simple example)
- documentAdd/documentRemove events
Occurs when a document is opened or closed in UltraEdit. Event is generated after the document action is complete in UltraEdit, so document action cannot currently be canceled from the plugin. This is an informational notification only. However it is useful for maintaining plugin awareness of available open documents. (See default Wizard Applet plugin for a simple example)
Example JavaScript handlers for plugin events:
JavaScript
//Called when a document is opened in UltraEdit
document.addEventListener(“uewve_documentAdd”, (event) => {
//Update plugin UI or other plugin objects as needed
});
//Called when a document is closed in UltraEdit
document.addEventListener(“uewve_documentRemove”, (event) => {
//Update plugin UI or other plugin objects as needed
});
//Called when the active theme is changed in UltraEdit
document.addEventListener(“uewve_themeChange”, (event) => {
//Refresh plugin UI with any theme changes
//from UltraEdit.theme object
});
//Called when all plugin initialization is complete
document.addEventListener(“uewve_apiInitialized”, (event) => {
//Plugin is fully initialized
//Put any one-time instantiation code here
});
This user guide provides the foundation for creating and using UltraEdit plugins. As the plugin system evolves, additional features and capabilities will be added to enhance the development experience and expand integration possibilities.