Modern SQL engines are enormously complex pieces of software. Even when they appear stable and mature, subtle bugs can hide in their optimizers, type systems, predicate evaluation, or execution layers. These bugs rarely announce themselves loudly. Instead, they quietly produce incorrect results, behave inconsistently, or fail abruptly under specific combinations of SQL constructs.

This is precisely why tools like SQLancer exist. SQLancer automatically generates SQL queries and uses logical “oracles” to detect when a database behaves incorrectly. It has revealed hundreds of real bugs in widely used systems such as MySQL, PostgreSQL, SQLite, and DuckDB.

With this in mind, I attempted to bring SQLancer to InterSystems IRIS, starting with the NOREC oracle — a powerful method for detecting optimizer correctness issues. The journey, however, uncovered not just potential SQL correctness problems, but also a surprising number of driver-level and server-level failures that prevented SQLancer from running at full strength.

This article summarizes why SQLancer is important, how the NOREC oracle works, and what unexpected findings appeared while testing IRIS.

The most upvoted idea on the InterSystems Ideas Portal—garnering 74 votes—requests a lightweight version of IRIS. While the platform has grown into a powerful data engine, many projects require only its SQL database capabilities. This article demonstrates how to build an unofficial, compact IRIS Community Edition image focused solely on core database functionality, reducing the image size by over 80%.

⚠️ Disclaimer

This project produces an unofficial, experimental image of InterSystems IRIS Community Edition.

• Not supported or endorsed by InterSystems.
• Use at your own risk. The modifications remove core platform features and may break compatibility with tools, APIs, and expected behaviors.
• No warranties or guarantees apply, including fitness for production use.
• Intended only for educational and experimental purposes by advanced users.

Why a Lightweight IRIS?

While IRIS today includes rich functionality—interoperability, analytics, machine learning, system management, etc.—many projects only require its core SQL capabilities. The official Community Edition Docker image is approximately:

• Disk usage: 3.5–3.8 GB
• Compressed size: ~1.1 GB

IRIS Light reduces that to:

• Disk usage: ~575–583 MB
• Compressed size: ~144–148 MB

This makes it suitable for:

• Microservice or containerized SQL use
• CI pipelines with faster startup and pull
• Horizontal scaling where full features are unnecessary

Over the past several years, the InterSystems Developer Community has accumulated more than 1,000 open-source projects. Many of them serve as examples and learning materials — but a significant number have become useful tools, libraries, integrations, and real-world components used in production.

Some of these projects are mine, and like many community developers, I’ve seen the same recurring problem:

• It’s easy to create an open-source project.
• It’s hard to maintain, support, and develop it sustainably — especially without funding.

Writing code is one thing.
Supporting it for years, keeping up with new IRIS versions, building CI pipelines, writing documentation, fixing issues, reviewing PRs — all of this demands both time and motivation, and the biggest motivator is often financial support.

This is not a new challenge.
The global open-source world has faced this for decades and has developed various models to support OSS ecosystems.

I believe it’s time for the InterSystems community to start a discussion about adopting a similar model.

Since we reached two important milestones for Go developers working with InterSystems IRIS:

• The Wait Is Over: Welcome GoLang Support for InterSystems IRIS — where we unveiled the new go-irisnative driver, providing a native database/sql interface for Go.
• GORM Meets InterSystems IRIS: Introducing gorm-iris — where we showed how to integrate IRIS with GORM, one of the most popular Go ORM libraries.

Now it’s time to see everything working together.

To demonstrate how easily Go developers can adopt InterSystems IRIS, I took an existing production-grade open-source project — the RealWorld Example App — which showcases a full-stack Medium.com-style clone implemented with Go Fiber, GORM, and SQLite.

With just a few configuration tweaks, I swapped out SQLite for gorm-iris, keeping everything else unchanged. The result?
A fully functional Go + Fiber application powered by InterSystems IRIS — no code rewrites, no ORM gymnastics, just a different database backend.

You can find the complete working demo here: github.com/caretdev/golang-fiber-iris-realworld-example-app

If you thought native Go support for IRIS was exciting, wait until you see what happens when GORM enters the mix.

Just recently, we welcomed native GoLang support for InterSystems IRIS with the release of go-irisnative. That was just the beginning. Now, we’re kicking things up a notch with the launch of gorm-iris — a GORM driver designed to bring the power of Object Relational Mapping (ORM) to your IRIS + Go stack.

Why GORM?

GORM is one of the most popular ORM libraries in the Go ecosystem. It makes it easy to interact with databases using Go structs instead of writing raw SQL. With features like auto migrations, associations, and query building, GORM simplifies backend development significantly.

So naturally, the next step after enabling Go to talk natively with IRIS was to make GORM work seamlessly with it. That’s exactly what gorm-iris does.

Introduction

The InterSystems IRIS Data Platform has long been known for its performance, interoperability, and flexibility across programming languages. For years, developers could use IRIS with Python, Java, JavaScript, and .NET — but Go (or Golang) developers were left waiting.

That wait is finally over.

The new go-irisnative driver brings GoLang support to InterSystems IRIS, implementing the standard database/sql API. This means Go developers can now use familiar database tooling, connection pooling, and query interfaces to build applications powered by IRIS.

Why GoLang Support Matters

GoLang is a language designed for simplicity, concurrency, and performance — ideal for cloud-native and microservices-based architectures. It powers some of the world’s most scalable systems, including Kubernetes, Docker, and Terraform.

Bringing IRIS into the Go ecosystem enables:

• Lightweight, high-performance services using IRIS as the backend.
• Native concurrency for parallel query execution or background processing.
• Seamless integration with containerized and distributed systems.
• Idiomatic database access through Go’s database/sql interface.

This integration makes IRIS a perfect fit for modern, cloud-ready Go applications.

Overview I'm excited to announce the release of testcontainers-iris-node, a Node.js library that makes it easy to spin up temporary InterSystems IRIS containers for integration and E2E testing. This project is a natural addition to the existing family of Testcontainers adapters for IRIS, including testcontainers-iris-python and testcontainers-iris-java.

Why testcontainers-iris-node? As a Node.js developer working with InterSystems IRIS, I often faced challenges when setting up test environments that mimic production. testcontainers-iris-node solves this by leveraging the testcontainers-node framework to create isolated IRIS environments on-demand.

This is particularly valuable for:

• Integration testing with IRIS databases
• Testing data pipelines or microservices
• Automating test environments in CI pipelines

Features

• Launches IRIS in Docker containers using Testcontainers
• Supports custom Docker images and configuration
• Wait strategies to ensure IRIS is ready before tests begin
• Clean teardown between test runs

Overview

The typeorm-iris project provides experimental support for integrating TypeORM with InterSystems IRIS, enabling developers to interact with IRIS using TypeORM’s well-known decorators and repository abstractions. This allows a more familiar development experience for JavaScript and TypeScript developers building Node.js applications with IRIS as the backend database.

While the project implements key integration points with TypeORM and supports basic entity operations, it’s not yet battle-tested or suitable for production environments.

What if you could speak in a chat to check what happens in Interoperability, is there any errors, and even solve some types of issues.

With MCP server, you can connect any of your MCP Client, for instance Claude, to IRIS, and ask to check on Interoperability

After so many years of waiting, we finally got an official driver available on Pypi

Additionally, found JDBC driver finally available on Maven already for 3 months,  and .Net driver on Nuget more than a month.

 As an author of so many implementations of IRIS support for various Python libraries, I wanted to check it. Implementation of DB-API means that it should be replaceable and at least functions defined in the standard. The only difference should be in SQL.

And the beauty of using already existing libraries, that they already implemented other databases by using DB-API standard, and these libraries already expect how driver should work.

I decided to test InterSystems official driver by implementing its support in SQLAlchemy-iris library.

From the previous article, we identified some issues when working with JSON in SQL.

IRIS offers a dedicated feature for handling JSON documents, called DocDB.

InterSystems IRIS® data platform DocDB is a facility for storing and retrieving database data. It is compatible with, but separate from, traditional SQL table and field (class and property) data storage and retrieval. It is based on JSON (JavaScript Object Notation) which provides support for web-based data exchange. InterSystems IRIS provides support for developing DocDB databases and applications in REST and in ObjectScript, as well as providing SQL support for creating or querying DocDB data.

By its nature, InterSystems IRIS Document Database is a schema-less data structure. That means that each document has its own structure, which may differ from other documents in the same database. This has several benefits when compared with SQL, which requires a pre-defined data structure.

The word “document” is used here as a specific industry-wide technical term, as a dynamic data storage structure. “Document”, as used in DocDB, should not be confused with a text document, or with documentation.

Let's explore how DocDB can help store JSON in the database and integrate it into projects that rely solely on xDBC protocols.

While working on getting JSON support for some Python libraries, I discovered some capabilities IRIS provided.

• JSON_OBJECT - A conversion function that returns data as a JSON object.
• JSON_ARRAY - A conversion function that returns data as a JSON array.
• IS JSON - Determines if a data value is in JSON format.
• JSON_TABLE function returns a table that can be used in a SQL query by mapping JSON.
• JSONPath support - is a query language for querying values in JSON.

So, we have docker image webgateway-nginx, marked as latest-em, which means supposed to be extended maintenance

$ docker run -it --entrypoint bash containers.intersystems.com/intersystems/webgateway-nginx:latest-em

root@9ca3373fe980:/# /opt/nginx/sbin/nginx -V
nginx version: nginx/1.21.5
built by gcc 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04) 
built with OpenSSL 1.1.

We have Webterminal around for quite a while, but it was limited, not all features worked there. There was no shell support or the latest feature as embedded Python support. There are some issues with tools that require programmer mode. Basic Authorization, not as handy as simple login page, where you could have options to add own login page, in case if you would wish to change the way how to login to the application, such as using SSO.

With the original iris terminal, wrapped into a web form, using most used in the web world xterm.js, used in tools like VSCode as well, with some magic from Python, which helped with interprocess tty. We can get the the terminal in the web, in the full capacity.

Started some work using WorkMgr, but then I noticed, that it stuck and does not get any responses from workers anymore

And I found that messages log contains logs about dead processes, why WorkMgr daemon did not restart died processes?

How to restart them without restarting IRIS

07/29/24-15:10:59:589 (856) 2 [Generic.Event] Process terminated abnormally (pid 949, jobid 0x0002001d)
07/29/24-15:10:59:603 (856) 0 [Generic.Event] cleaned dead job, pid: 949, jobid 0x0002001d
07/29/24-15:10:59:603 (856) 2 [Generic.

For a few latest versions, I noticed that Web Applications got some support for JWT Authentication

During the realization of some required functionality, I discovered that I need to use Deflate compression, and found, that IRIS does not offer any options, $system.Util.Compress, works one way open (GZIP/COMPRESS) totally different, even for the same algorithms, I see that what I would expect as a result for Deflate somewhere there, but Compress returns something more. Is there any way to get a correct result using just ObjectScript without a need to use external tools? Was it really so difficult to have Deflate implemented in the first place?

What is the point of having a dedicated registry if it does not work properly most of the time?

$ docker pull containers.intersystems.com/intersystems/iris-community:latest-em
latest-em: Pulling from intersystems/iris-community
5526e9f3d5c5: Already exists
352b407541ae: Already exists
f6bff04f5338: Already exists
8c3b528467ff: Downloading [=======================>                           ]  125.8MB/262.2MB
e2b23b0bff05: Downloading [=============>                                     ]  124.8MB/462.1MB
failed to copy: httpReadSeeker: failed open: could not fetch content descriptor sha256:8c3b528467ff8cc07d86a4979e3e7b8fd36734205539923c8750e1d523f23367 (application/vnd.docker.image.rootfs.diff.tar.gzip) from remote: not found

Once again I would like to know, if there are any plans to make Java libraries available through normal channels like public mvnrepository, like the whole world it's doing, where anyone can find any JDBC driver to any database in the world but InterSystems.

Currently there is only some useless garbage. There are just very empty files. What was the point of posting it there?

I'm really interested in contributing, but this issue is a huge stopper, and I don't want to do anything.

@Bob Kuszewski @Jeffrey.

I would like to share some of the latest projects I've implemented

Is there any solution to how to purge the usage of the connection in Community Edition?

I have a working portal, where can't do even any simple SQL Query

Why?

Nowadays so much noise around LLM, AI, and so on. Vector databases are kind of a part of it, and already many different realizations for the support in the world outside of IRIS. 

Why Vector?

• Similarity Search: Vectors allow for efficient similarity search, such as finding the most similar items or documents in a dataset. Traditional relational databases are designed for exact match searches, which are not suitable for tasks like image or text similarity search.
• Flexibility: Vector representations are versatile and can be derived from various data types, such as text (via embeddings like Word2Vec, BERT), images (via deep learning models), and more.
• Cross-Modal Searches: Vectors enable searching across different data modalities. For instance, given a vector representation of an image, one can search for similar images or related texts in a multimodal database.

And many other reasons.

So, for this pyhon contest, I decided to try to implement this support. And unfortunately I did not manage to finish it in time, below I'll explain why.

In today's landscape, enterprises have grown substantially in scale, amassing vast amounts of data. This data is collected from a plethora of sources including different applications, databases, and other channels. Given the diversity and volume of this data, it's only logical for these enterprises to seek a deeper understanding of what their data entails. Some of the data can be stored in IRIS, and it can be reasonable to be able to add this data to a data lake too.

The Internet now offers many different tools for such tasks, that do not yet support IRIS, but it's achievable.

For the upcoming Python contest, I would like to make a small demo, on how to create a simple REST application using Python, which will use IRIS as a database. Using this tools

• FastAPI framework, high performance, easy to learn, fast to code, ready for production
• SQLAlchemy is the Python SQL toolkit and Object Relational Mapper that gives application developers the full power and flexibility of SQL
• Alembic is a lightweight database migration tool for usage with the SQLAlchemy Database Toolkit for Python.
• Uvicorn is an ASGI web server implementation for Python.

As an example of an application on Java working with Hibernate dialect for IRIS, wanted to use RealWorld application, and found realization for Quarkus. RealWorld application is an example of an application close to some real one, with already prepared tests for the backend. Most of the examples of realizations can be found here

The RealWorld example application is often referred to as the "Wikipedia for building full-stack applications." It serves as a standardized prototype that developers can use to create applications using various programming languages and frameworks. The application provides a real-world use case by mimicking a blogging platform, complete with features like user authentication, profile management, article posting, and comments. With a comprehensive set of specifications, including ready-made backend API documentation and frontend designs, it allows developers to see how the same functional requirements are implemented across different technology stacks. The RealWorld example is widely used as a learning tool and a benchmark for comparing various technologies.

Quarkus

Quarkus is an open-source, Kubernetes-native Java framework tailored for the GraalVM and HotSpot. Created with the aim to enhance the modern cloud-native environment, it significantly reduces the footprint and startup time of Java applications. Quarkus is known for its "container-first" philosophy, allowing developers to build lightweight, high-performing applications with a focus on microservices architecture. This flexibility has made it a popular choice for organizations looking to transition into serverless or cloud-based platforms, combining both imperative and reactive programming models. Whether it's a traditional web application or a complex system of microservices, Quarkus provides a robust platform for building scalable and maintainable software.

Well, now we got noPWS container with IRIS, and how to connect to it, simply, without any durable sys or files, using normal peoples way like Environment variables?

version: "3"
services:
  iris:
    image: containers.intersystems.com/intersystems/iris:2023.2.0.227.0
    ports:
      - 1972:1972
    volumes:
      - ~/iris.key:/usr/irissys/mgr/iris.key
  web:
    image: containers.intersystems.com/intersystems/webgateway:2023.2.0.227.0
    ports:
      - 52773:80

So, I needed to start Java Gateway, and found, that it does not want to work with the latest Java versions, I tried 20, 18, 17

Error, only says, that it will not work, and say nothing, about which version it wants to see

InterSystems IRIS offers various ways how to profile your code, in most cases it produces enough information to find the places where the most time is spent or where the most global sets. But sometimes it's difficult to understand the execution flow and how it ended at that point. 

To solve this, I've decided to implement a way to build a report in a way, so, it's possible to dive by stack down

How to understand what's wrong with compilation if the compilator just hides errors?

Compilation started on 05/15/2023 15:58:11 with qualifiers 'cuk'

Detected 1 errors during compilation in 0.003s.


Compilation started on 05/15/2023 15:58:32 with qualifiers 'cuk'

Detected 1 errors during compilation in 0.002s.


Compilation started on 05/15/2023 15:58:51 with qualifiers 'cuk'

Detected 40 errors during compilation in 0.089s.

40 errors, and what do I have to do with this so valuable information?

Apache Superset is a modern data exploration and data visualization platform. Superset can replace or augment proprietary business intelligence tools for many teams. Superset integrates well with a variety of data sources.

And now it is possible to use with InterSystems IRIS as well.

An online demo is available and it uses IRIS Cloud SQL as a data source.