VS Code and Marble: A Modern IFS Development Setup

IFS Marble development traditionally centers on IFS Developer Studio — a robust, purpose-built IDE. But modern development workflows increasingly demand flexibility. VS Code, with its extensibility and ecosystem, has become the choice for developers who want a lightweight, customizable environment without sacrificing productivity.

This guide walks you through setting up VS Code as a professional-grade IFS Marble development platform, integrating it seamlessly with Developer Studio while adding your own power-user tooling.

Why VS Code for IFS Development?

IFS Developer Studio is powerful, but VS Code offers distinct advantages:

• Speed and responsiveness: VS Code launches instantly and stays lean, even with dozens of extensions.
• Customization: Tailor keybindings, themes, and workflows to your exact needs.
• Integration with modern tools: Git, Docker, terminals, debugging protocols, and CI/CD pipelines integrate naturally.
• Extension ecosystem: Thousands of community extensions address specific workflows.
• Cross-platform consistency: Same experience on Windows, macOS, and Linux.

The goal isn't to replace Developer Studio — it's to create a complementary environment where you can draft, test, and validate Marble logic with VS Code's agility, then leverage Developer Studio's validation and deployment features.

Essential Extensions for IFS/XML/Marble Development

1. XML Language Support by Red Hat

The XML Language Support extension (by Red Hat) is the foundation for Marble work. It provides:

• Syntax highlighting with proper XML scoping
• Schema validation against XSD definitions (crucial for Marble XML structure)
• Auto-completion based on schema constraints
• Document outline with customizable symbols display
• Error aggregation for schema violations
• Quick fixes for common XML mistakes (missing closing tags, malformed attributes)

Installation: Open Extensions (Ctrl+Shift+X), search redhat.vscode-xml, install.

Key settings for Marble:

The Red Hat extension uses LemMinX (Language Server for XML), which can be extended to support custom completions and validation rules specific to your IFS dialect.

2. XML Tools

XML Tools (by DotJoshua) supplements the Red Hat extension with:

• XPath queries to navigate large XML files
• Pretty-printing and minification
• Tag renaming
• Attribute reordering

Install from the Marketplace as dotjoshua.xml.

3. Prettier - Code Formatter

Marble XML must follow strict formatting conventions. Prettier with XML support ensures consistency:

Install: esbenp.prettier-vscode

4. GitLens — Git Supercharged

For Marble files tracked in version control (highly recommended), GitLens provides:

• Inline blame annotations
• File history and commit details
• Branch comparisons

Install: eamodio.gitlens

Knowing who last modified a Marble expression and why is invaluable for debugging logic errors.

5. Thunder Client or REST Client

IFS Marble often integrates with APIs and webhooks. Thunder Client (or REST Client by Huachao Mou) lets you test integrations without leaving VS Code:

• Test workflow REST APIs
• Validate request/response payloads
• Store and organize API collections

Install: rangav.vscode-thunder-client or humao.rest-client

6. Code Spell Checker

Marble configurations often contain business logic descriptions and variable names. Code Spell Checker catches typos:

• Spell checks comments and strings
• Supports custom dictionaries (add IFS-specific terminology)

Install: streetsidesoftware.code-spell-checker

7. VS Code Icons (Optional but Recommended)

Visual cues matter. VS Code Icons improves file recognition:

• Distinctive icons for .xml, .xsd, and Marble-specific files
• Easier navigation in large projects

Install: vscode-icons-team.vscode-icons

Custom Syntax Highlighting for Marble Expressions

While the Red Hat XML extension handles XML structure, you can enhance Marble-specific elements with custom TextMate grammar rules. VS Code uses TextMate grammars — sets of regex patterns that tokenize code and assign scopes.

Creating a Marble Syntax Injection Grammar

1. Create a local grammar file in your workspace:

   .vscode/syntaxes/marble-injection.json
   

2. Define an injection grammar to highlight Marble keywords:

3. Register the grammar in package.json (if you're developing an extension) or .vscode/extensions.json for workspace-specific settings.

4. Assign colors via your theme:

The scope inspector (Ctrl+Shift+P → "Inspect Editor Tokens") helps you debug grammar rules and see what scopes are active at your cursor position.

Custom Snippets for Marble Development

Snippets dramatically speed up repetitive Marble configurations. VS Code snippets use TextMate syntax with support for tabstops, placeholders, and variable transforms.

Creating Marble Snippets

1. Open the snippets editor: Ctrl+Shift+P → "Configure User Snippets" → Select "xml" (or create a global .code-snippets file).

2. Define common Marble patterns:

Action Snippet:

Conditional Snippet:

API Call Snippet:

Workflow Definition Snippet:

Pro tip: Use file template snippets (with "isFileTemplate": true) to auto-populate new Marble files with boilerplate structure.

Organizing Project-Level Snippets

For team consistency, create project-level snippets in .vscode/marble.code-snippets:

Commit this file to version control so all team members get consistent snippets.

Debugging Marble Workflows

Marble debugging in VS Code requires integration with IFS tools. While VS Code doesn't natively debug Marble runtime, you can set up several debugging strategies:

1. Output-Driven Debugging

The simplest approach: add logging actions to your Marble workflows and view output.

Marble Snippet for Debugging:

2. External Debugging via Tasks

Configure VS Code tasks to run Marble validations against IFS Developer Studio or a local test instance:

.vscode/tasks.json:

Run with Ctrl+Shift+B (Build) or Ctrl+Shift+P → "Run Task".

3. REST Client for Testing

Test Marble-triggered APIs directly in VS Code:

.vscode/requests.http:

Click "Send Request" to test without leaving VS Code.

File Structure and Project Organization

Organize your IFS Marble project efficiently:

my-ifs-project/
├── .vscode/
│   ├── settings.json
│   ├── launch.json
│   ├── tasks.json
│   ├── marble.code-snippets
│   ├── syntaxes/
│   │   └── marble-injection.json
│   └── extensions.json
├── marble/
│   ├── workflows/
│   │   ├── order-processing.xml
│   │   ├── invoice-generation.xml
│   │   └── _common.xml (shared definitions)
│   ├── actions/
│   │   ├── api-integrations.xml
│   │   ├── data-transforms.xml
│   │   └── validations.xml
│   ├── schemas/
│   │   └── marble-schema.xsd
│   └── tests/
│       ├── workflow-tests.xml
│       └── test-data.json
├── docs/
│   ├── workflow-guide.md
│   └── action-reference.md
├── .gitignore
├── README.md
└── package.json (if using npm for tooling)

Settings for This Structure

.vscode/settings.json:

Integrating with IFS Developer Studio

VS Code and Developer Studio work best as complementary tools, not rivals.

Recommended Workflow

1. Draft and test in VS Code:

   • Write Marble XML with snippets and syntax highlighting.
   • Use the REST Client extension to test API endpoints.
   • Validate against schema and run linting tasks.

2. Validate in Developer Studio:

   • Import your XML files.
   • Run Developer Studio's built-in validation and type checking.
   • Test workflow execution in a sandbox environment.

3. Deploy from Developer Studio:

   • Developer Studio handles deployment, versioning, and rollback.
   • VS Code remains your editing and collaboration tool.

Sync Between Editors

Use file watchers and Git to keep files in sync:

.vscode/settings.json:

When you edit in Developer Studio, commit changes. When you edit in VS Code, push to your repo and pull in Developer Studio (or vice versa).

Developer Studio Extensions

If you're comfortable with VS Code extension development, consider creating a Developer Studio integration extension:

• Deploy from VS Code: Right-click a Marble file → "Deploy to Developer Studio"
• Fetch from Developer Studio: Sync workflows from a remote instance
• Real-time validation: Check against Developer Studio's validation rules

This would require the IFS Developer Studio API documentation and custom extension scaffolding.

Productivity Tips and Power-User Features

1. Multi-Cursor Editing

Edit multiple Marble expressions simultaneously:

• Hold Ctrl and click to add cursors.
• Select a word and press Ctrl+D to select the next occurrence.
• Use Ctrl+Shift+L to select all occurrences of the current word.

Useful for renaming variables across actions.

2. Find and Replace with Regex

Search for complex patterns in your Marble definitions:

Example: Find all API calls with a specific method:

<apiCall method="GET"[^>]*>

Replace with:

<apiCall method="POST"$0>

Ctrl+H opens Find and Replace. Enable regex mode (.*) for power queries.

3. Bracket Pair Colorization

Marble XML can get deeply nested. Enable Bracket Pair Colorization to track nesting:

.vscode/settings.json:

4. Outline and Breadcrumb Navigation

The Outline pane (Ctrl+Shift+O) and Breadcrumb (top of editor) show your position in the XML hierarchy. Click to jump to any element.

For large workflows with 100+ actions, this is a game-changer.

5. Diff Editor for Comparing Versions

Marble logic often evolves. Compare two versions:

• Open a file, then Ctrl+K Ctrl+O (Open to the Side).
• Drag another version into the new pane.
• VS Code highlights differences in real-time.

6. Command Palette for Quick Actions

Memorize these:

• Ctrl+Shift+P: Open Command Palette.
• Configure User Snippets: Add or edit snippets on the fly.
• Format Document: Ctrl+Shift+I (apply Prettier).
• Inspect Editor Tokens: Debug syntax highlighting.
• Insert Snippet: Browse and insert available snippets.

7. Keybinding Customization

Create a .vscode/keybindings.json for Marble-specific shortcuts:

Now Ctrl+Alt+M inserts a workflow template instantly.

Key Takeaways

1. VS Code enhances — not replaces — Developer Studio: Use VS Code for drafting and iteration, Developer Studio for validation and deployment.

2. The Red Hat XML extension is essential: Syntax highlighting, schema validation, and auto-completion are non-negotiable for Marble work.

3. Snippets are force multipliers: Custom snippets eliminate boilerplate and encode team best practices.

4. Debugging relies on integration: Use logging, tasks, and REST Client extensions to validate Marble logic before deployment.

5. Structure matters: Organize workflows, actions, and schemas clearly so your team can navigate and maintain Marble code at scale.

6. Leverage version control: Git + VS Code's GitLens integration turn Marble workflows into auditable, collaborative artifacts.

7. Invest in tooling: Custom syntaxes, keybindings, and tasks pay dividends across your entire team.

Next Steps

1. Install the core extensions (Red Hat XML, GitLens, Prettier, REST Client).
2. Create a .vscode/ folder in your IFS project with shared settings and snippets.
3. Set up one or two snippets for your most common Marble patterns.
4. Configure schema validation against your IFS instance's Marble schema.
5. Test the REST Client with a simple API call to validate your workflow endpoints.
6. Share your setup with your team — consistency amplifies the benefits.

VS Code, configured thoughtfully, becomes a powerful ally for IFS Marble development. The combination of speed, extensibility, and seamless Developer Studio integration makes it an indispensable tool in the modern IFS developer's toolkit.

---

About the Author: Syrett Consultancy specializes in IFS Cloud customization and integration. We help organizations unlock the full potential of their IFS deployments through expert consulting, implementation, and continuous optimization.