NoSQLBooster 11.0 Released! Embedded Mongosh Engine, Native Apple Silicon, and More

We are thrilled to announce the release of NoSQLBooster 11.0 — the most significant upgrade in the product's history. This major version embeds the latest mongosh engine (v2.8) directly into the IDE, delivering full MongoDB Shell compatibility with top-level await, modern ES6+ syntax, and all the latest aggregation operators. The data viewer has been completely rebuilt on AG-Grid for faster rendering and inline cell editing. On macOS, NoSQLBooster now ships native Apple Silicon builds for M1/M2/M3/M4 Macs, and the entire application has been upgraded to support MongoDB 3.6 through 8.0 with improved performance and security.

This release represents over 1,500 commits of engineering effort, delivering a faster, more secure, and more feature-rich MongoDB administration experience.

If you want to try NoSQLBooster 11.0 out now, you can get it from the following link.

NoSQLBooster 11.0 Download Link

The product will automatically enter the 30-day trial mode after a successful installation. At the end of the 30-day trial period, the product becomes a free edition. The free version is free for personal/commercial use but with limited functions.

The following figure shows the main interface of version 11.0.

Main interface

Let's dive in and get an overview of what's coming in NoSQLBooster 11.0!

Although we are showing screenshots of NoSQLBooster for Windows, all these new features are available for macOS and Linux as well.

What's new?

Embedded Mongosh Engine (v2.8)

The headline feature of NoSQLBooster 11.0 is a completely rewritten embedded MongoDB Shell engine. NoSQLBooster 11.0 adopts @mongosh/async-rewriter2 — the same technology that powers the official MongoDB Shell — effectively embedding the latest mongosh engine (CLI version 2.8.2) directly into the IDE. This gives you a first-class mongosh experience without leaving the graphical environment.

What this means for your daily work:

  • Full mongosh compatibility — any script written for the official mongosh works in NoSQLBooster without modification
  • Top-level await — your own async code (custom Promises, fetch, etc.) can use await directly at the top level; shell-api methods like find(), toArray() are auto-resolved as before
  • All MongoDB 8.0 operators — every new aggregation stage and operator from MongoDB 8.0 is available immediately
  • Better error messages — source-mapped stack traces point to the exact line in your script, not to internal engine code
  • Cross-platform consistency — identical behavior on Windows, macOS, and Linux
1
2
3
4
5
6
7
8
9
// Fluent cursor API — works without await, same as before
var recentOrders = db.orders.find({ status: "shipped" })
    .sort({ orderDate: -1 })
    .limit(20)
    .toArray();

for (const order of recentOrders) {
    print(`${order.customer} — $${order.total}`);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
// Modern JavaScript + aggregation pipeline + top-level await
var topCustomers = db.orders.aggregate([
    { $match: { year: 2024 } },
    { $group: { _id: "$customerId", totalSpent: { $sum: "$amount" } } },
    { $sort: { totalSpent: -1 } },
    { $limit: 5 }
]).toArray();

// Your own async code works with top-level await
var response = await fetch("https://api.example.com/loyalty-tiers");
var tiers = await response.json();

topCustomers.forEach(c => print(`${c._id}: $${c.totalSpent}`));

Rebuilt Data Viewer with AG-Grid

The data viewer has been rebuilt from the ground up on AG-Grid, delivering a significantly improved experience for browsing and editing query results. Key improvements include:

  • Nested field column groups — nested document fields are automatically organized into collapsible column groups (e.g., address.city, address.zip are grouped under address), making deeply structured MongoDB documents easy to navigate
  • WebGL-accelerated rendering — large datasets render with hardware acceleration; the application automatically detects WebGL support and prompts accordingly
  • Column state persistence — column widths, ordering, and visibility are remembered between sessions
  • JSON Viewer large content handling — when JSON output exceeds 2MB, the viewer initially shows the first 500KB for instant responsiveness, with a "Show All Content" button to load the full content on demand
  • Inline cell editing — press Enter on any editable cell to modify values directly in the table, no separate dialog needed
  • show dbs / show tables in table view — these common commands now display results in a clean table view automatically instead of plain text
  • Encrypted field detection — CSFLE/Queryable Encryption fields are identified via schemaMap, encryptedFieldsMap, and runtime BinData(6) detection, and clearly marked in the data view
  • DBRef follow reference — clicking a database reference opens the related document in a new shell tab for seamless navigation
  • Double-click to locate in tree — double-click the collection icon in the data viewer toolbar to automatically expand and scroll to that collection in the object explorer tree
Nested Field Column Groups

Native Apple Silicon Support

NoSQLBooster 11.0 now provides separate native builds for Intel (x64) and Apple Silicon (arm64) Macs. If you're using an M1, M2, M3, or M4 Mac, you can now run NoSQLBooster natively — no more Rosetta 2 translation overhead.

  • Native performance — the application runs directly on Apple Silicon, delivering faster query execution and smoother UI interactions
  • Faster startup and lower memory usage compared to the translated x64 build
  • Separate DMG installers for each architecture — download the one that matches your Mac

This release also resolves the macOS Tahoe (macOS 26) system-wide lag issue that affected Electron-based applications.

macOS Builds

Modernized Technology Stack

To support the new mongosh engine and deliver a better overall experience, NoSQLBooster 11.0 has been rebuilt on a modernized technology stack. While these changes are mostly under the hood, they provide the foundation for faster performance, improved stability, and future feature development.

Component Version 10.x Version 11.0
Electron 11.5 40.9
Chromium 87 134
Node.js 12.x 22.x
MongoDB Node.js Driver 6.9 7.2
BSON 6.7 7.0
Frontend Framework Vue 1.x Vue 3.5
Data Grid EasyUI AG-Grid 34.2

The modern Chromium engine delivers better rendering performance, improved security, and full support for modern web standards. The upgraded frontend framework brings significantly faster UI rendering, and the switch to AG-Grid enables inline editing, WebGL-accelerated large dataset rendering, and advanced column management in the data viewer.

Feature Highlights

Beyond the foundational platform changes, NoSQLBooster 11.0 delivers a wealth of functional improvements that enhance day-to-day productivity. Here are the most notable features organized by category.

Visual Query Builder

The Visual Query Builder has been completely rewritten for better responsiveness and a cleaner layout. Query construction is now faster and more intuitive, with improved drag-and-drop interactions and real-time preview of generated query conditions.

Visual Query Builder

Script Debugger

The built-in script debugger works reliably with the new mongosh engine:

  • Accurate source mapping — breakpoints map correctly to your original script code, even when the engine transforms it behind the scenes
  • Proper script termination — stopping at a breakpoint correctly terminates the script instead of letting it continue to completion
  • Sandboxed debugging — debugger operations are isolated from the main application for stability

Batch Copy Multiple Databases

You can now select multiple databases and copy them to a target server in a single operation, instead of copying them one by one. This is a great time-saver when migrating or consolidating databases across servers.

Additionally, the Rename Database script template has been significantly improved. Since MongoDB does not provide a native rename command, NoSQLBooster implements this by moving all collections and users to the new database, with smarter error handling and automatic cleanup of the empty source database.

Non-Intrusive Tree Node Tooltips

In previous versions, hovering over any node in the connection tree would immediately pop up a tooltip — often blocking the node name and surrounding information during normal browsing. Version 11.0 fixes this by adding a dedicated info icon to the right of each tree node (connections, databases, collections, indexes, and more). The tooltip now only appears when you hover over this icon, so it never interferes with reading the tree. Each node type shows its own contextual information — for example, index nodes display live indexStats (access counts, operation statistics), while collection nodes show document count and storage size.

Collection Tooltip

DBRef Follow Reference with One-Click SQL JOIN

The Follow Reference dialog now features a "SQL JOIN in shell" button that instantly generates an equivalent SQL JOIN ($lookup) statement based on the DBRef relationship. This is a great time-saver when you need to explore relationships between collections:

  • One-click generation — click the button and NoSQLBooster opens a new shell tab with the SQL JOIN query, pre-filled and auto-executed
  • Cross-database awareness — if the referenced collection is in a different database, a warning comment is added to the script since $lookup requires both collections in the same database
  • Smart field mapping — the generated query automatically maps the source field (e.g. orders.userId) to the target collection's _id
1
2
3
4
// Generated SQL JOIN from a DBRef field "userId" referencing "users" collection
mb.runSQLQuery(`
    SELECT orders.*, users.* FROM orders JOIN users ON "orders.userId" = "users._id";
`)

The equivalent native mongosh statement uses the $lookup aggregation operator:

1
2
3
4
5
6
7
8
db.orders.aggregate([{
    $lookup: {
        from: "users",
        localField: "userId",
        foreignField: "_id",
        as: "userDetails"
    }
}])

Intelligent Document Preview

The document preview in the tree/table view has been enhanced with intelligent field selection that picks the most meaningful fields to display:

  • Multi-language field name matching — recognizes common field names across 8 languages (English, Chinese, Japanese, Korean, Spanish, French, German, Portuguese) using deburred snake-case normalization
  • Smart identifier filtering — automatically skips GUID/ObjectId/UUID/MD5 values that carry no semantic meaning for preview purposes
  • Priority-ordered display — fields are shown by importance priority rather than raw document key order, so the most informative fields appear first

For example, a document with {_id: ObjectId("..."), nombre: "Carlos", apellido: "García", email: "carlos@example.com"} will intelligently prioritize nombre and email in the preview rather than starting with the _id.

Enhanced Connection Tree

The database object explorer has received substantial improvements for navigating large connection trees:

Smart Node Filtering

The tree search now supports namespace-format filtering — you can type patterns like db.collection to precisely locate nodes deep in the hierarchy. The filter logic matches against both the node's own name and its ancestor chain, so sales.orders will match the orders collection under the sales database.

  • Word-level matching — type partial words to match nodes and their ancestors
  • Namespace format — use database.collection syntax for precise filtering
  • Flexible partial matching — empty parts are allowed for maximum flexibility
Connection Tree Search

Large Connection Search Confirmation

When searching in a connection tree that contains a large number of databases/collections, NoSQLBooster now detects the scale and prompts for confirmation before proceeding, preventing accidental performance impacts. A loading indicator is shown during the search, and you can cancel the operation at any time to stop the backend query.

Text Truncation with Full Tooltip

Long node names in the connection tree are now truncated in the middle (e.g., very_long_collection...suffix) rather than being clipped at the end, preserving both the beginning and ending of the name. The full name is displayed in a tooltip on hover.

Auto TypeScript Mode Detection

The script editor can now automatically detect whether a script file should be opened in TypeScript mode based on its content. If the editor detects TypeScript-specific syntax (type annotations, interfaces, etc.), it will switch to TypeScript parsing without requiring manual mode selection.

Query Profiler Enhancement

A new "Clean Profiled Data" option allows you to clear all collected profiler data while keeping the profiler running. Previously, you had to turn off the profiler to clean up its data. This is useful when you want to start a fresh profiling session without interrupting the monitoring workflow.

Clean Profiled Data

Toolbar and UI Improvements

  • Text selection enabled globally — all UI elements now allow text selection (user-select: auto), making it easy to copy values, error messages, and other text from the interface; previous versions blocked text selection by default
  • Clear recent files — a new toolbar action to clear the recent files list with one click
  • MongoShell icon — the toolbar now features a dedicated MongoShell icon for quick shell access
MongoShell icon

Connection Editor

The "More" tab in the connection editor has been enhanced with a comprehensive set of MongoDB URI options:

  • Complete URI option catalog — all standard MongoDB URI options are now available in the "Add URI Option" dialog, no need to remember option names
  • Categorized display — options are grouped by function: Connection Timeout, Connection Pool, Write Concern, Read Concern, Read Preferences, Server, Compression, and Miscellaneous
  • Inline tooltips — hovering over an option shows a clear description of what it does (e.g., connectTimeoutMS: "How long to wait for a connection to be established before timing out")
  • Default value pre-fill — selecting an option automatically fills in its recommended default value
URI option catalog

Security and Authentication

Enhanced Authentication

  • Kerberos (GSSAPI) connection options — selecting Kerberos as the authentication mode now reveals a dedicated set of form fields for easy configuration: Service Name (SPN), Canonicalize Host, Service Realm (for cross-realm authentication), and Service Host (SPN host override); these were previously unavailable and required manual URI string editing
  • OIDC self-hosted endpoints — connect to your organization's own OIDC provider with a new "Consider Target Endpoint Trusted" tri-state option
  • Auth mode validation unified across frontend and backend for consistent security policy enforcement
Kerberos connection options

Application Security

  • Dynamic Content Security Policy — CSP is now injected at runtime, enabling support for custom AI API endpoints while maintaining security
  • Reduced attack surface — Electron Fuses lock down security-critical features at build time; unused Chromium features are disabled
  • HTTPS enforcement — all external resource loading upgraded from HTTP to HTTPS

Faster Startup

NoSQLBooster 11.0 launches noticeably faster thanks to several optimizations:

  • V8 compile cache — JavaScript code is cached after first compilation, reducing subsequent startup time
  • Deferred initialization — non-essential features load on demand rather than at launch
  • Non-blocking file dialogs — opening and saving files no longer freezes the UI

Data Import and Export

Export with Global Date Format Settings

When exporting query results to CSV or Excel, the export now respects the global dateFormat and utcOffset settings configured in the application. This ensures date/time values in exported files are consistent with your display preferences, eliminating the need for post-export formatting.

  • Follow Global selection — the export dialog automatically follows the global date format setting
  • Progress feedback — XLSX, HTML, and TXT exports now report progress to the frontend via sandbox console, so you always know how far along the operation is
Export Date Format

Improved MongoDB Tools Path Configuration

The configuration for external MongoDB tools (mongodump, mongoexport, mongoimport) has been refactored with a caching mechanism for faster access. Path handling has been improved to correctly support spaces and UNC paths on Windows.

SQL Import and MongoDB Tools

SQL Import Enhancement

The SQL Import feature has been significantly improved with smarter table/view handling and safer name mapping:

  • Table vs View recognition — SQL tables and views are now distinguished automatically via INFORMATION_SCHEMA (MySQL/MSSQL) or pg_catalog (PostgreSQL); views are marked with a (view) label in the import list
  • Views unchecked by default — since views contain derived data, they are not selected for import by default, preventing redundant data duplication
  • Automatic name sanitization — source table names and column names containing characters unsafe for MongoDB (., $, whitespace, /, \, \0) are automatically converted to safe identifiers (e.g., dbo.users → dbo_users, first name → first_name)
  • Field mapping auto-suggestions — when choosing which fields to import, columns with unsafe characters automatically show a sanitized destination field name
  • Editable connection combobox — easily switch between SQL database connections
  • Tree refresh with focus — tree view automatically refreshes and focuses on newly imported collections
  • Northwind sample URI — includes a sample connection string for quick testing

MongoDB Tools Integration

  • Refactored MongoDB Tools (mongodump, mongoexport, mongoimport) path configuration with caching
  • Fixed export path component handling for spaces and UNC paths on Windows
  • Increased execAsync buffer size for large operations

Mock Data Generator

The Test Data Generator has been renamed to Mock Data and received significant usability improvements:

  • Renamed to "Mock Data" — the toolbar button now displays "Mock Data" for a clearer, more concise name
  • Array field hint ($) — a tip banner at the top of the dialog explains how to generate arrays: append .$ to a field name (e.g., tags.$ generates an array of values; items.$.productName generates an array of objects)
  • Preset templates — 9 built-in templates for common data patterns: Card, User Card 1/2, E-Commerce Order, Blog Post, Employee, Product Catalog, Transaction, and IoT Sensor Log; each pre-fills field names, types, and collection names
  • Refactored field type list — field types are now dynamically fetched with virtual-scroll support, showing inline examples on hover for easier selection
  • Robust error handling — field-type errors are surfaced clearly, and null-connection scenarios are handled gracefully
Mock Data Generator

AI Helper

The built-in AI Assistant has been upgraded with an improved backend model and smarter prompts:

  • Upgraded backend LLM — the AI Helper now uses a more capable language model on the backend, delivering higher-quality responses and better code generation
  • Smarter MongoDB prompts — system prompts have been refined to generate more accurate MongoDB shell statements that can be directly copied and executed in NoSQLBooster
  • Collapsible panel — the AI chat panel can now be fully hidden when collapsed (previously it remained visible as a narrow sidebar), reclaiming valuable screen real estate for the data viewer and script editor
  • Custom AI endpoint support — users can configure their own AI API endpoints; dynamic CSP (Content Security Policy) automatically adjusts to allow custom endpoints while maintaining security

Other Notable Improvements

Task Management

  • Copy command line for multiple shells (Windows) — the "Copy Command Line" menu now offers three shell formats: CMD, PowerShell, and Git Bash, each generating the correct syntax for that shell (e.g., PowerShell uses $env:Path and & operator; Git Bash uses export PATH=...); previously only CMD format was available
  • Enhanced task connection status checking with color marking for quick visual identification
  • Improved Linux headless mode and CLI compatibility (AppImage command fix, X Server crash fix)
  • Cron task environment compatibility improvements for Linux

Schema Explorer

  • Optimized Schema Analyzer connection management and error handling
  • Fixed async collection statistics retrieval
  • Improved toolbar styling and button spacing

Miscellaneous

  • Upgrade MongoDB Node.js driver to 7.2
  • Upgrade BSON to 7.0
  • Upgrade embedded mongosh to CLI version 2.8.2
  • Remove Google Analytics integration for improved privacy
  • GridFS contentType storage and edit dialog display restored
  • Cross-platform multi-cell selection fix for macOS/Linux
  • Logger window toolbar optimization and pause state synchronization

Breaking Changes and Migration

Due to the fundamental engine rewrite, NoSQLBooster 11.0 introduces several breaking changes. We've prepared a detailed Migration Guide with side-by-side code examples. Here is a summary of the key changes:

Shell Script Migration (Fibers → Mongosh)

Mongosh's async-rewriter automatically resolves shell-api promises (e.g. find(), toArray(), countDocuments()) — so most scripts work without modification. However, there is one critical behavioral difference:

.forEach(async () => {}) must be converted to for...of

The async-rewriter cannot transform async callbacks inside .forEach(). This is the most common migration issue:

1
2
3
4
5
6
7
8
9
// ❌ v10.x — async callback in forEach worked via Fibers, but WILL FAIL in v11.0
db.users.find({ status: "active" }).forEach(async function(user) {
    await db.logs.insertOne({ userId: user._id, action: "audit" });
});

// ✅ v11.0 — use for...of so the async-rewriter can handle it properly
for (const user of db.users.find({ status: "active" }).toArray()) {
    db.logs.insertOne({ userId: user._id, action: "audit" });
}

Other minor differences

1
2
3
4
5
6
7
8
9
10
11
// ❌ cursor.count() is deprecated (since MongoDB 4.0)
var count = db.users.find({ status: "active" }).count();

// ✅ use countDocuments() or estimatedDocumentCount()
var count = db.users.countDocuments({ status: "active" });

// ❌ cursor.map() returned an Array in v10.x
var names = db.users.find().map(u => u.name);

// ✅ cursor.map() returns a Cursor in v11.0, call .toArray()
var names = db.users.find().map(u => u.name).toArray();

Shell-api methods like find(), insertOne(), aggregate() etc. do not need await — only your own custom Promises and non-shell-api async calls do.

In-Use Encryption Configuration Format

The autoEncryptionOptions are now stored as a JavaScript expression (autoEncryptionOptionsJs field) instead of a plain JSON object. This fixes a critical bug where BSON types (UUID/BinData) in keyId arrays lost their prototypes through JSON serialization, causing libmongocrypt error 51088.

  • Existing configurations are backward compatible — the old field is preserved as fallback
  • Re-saving the connection in the editor will migrate to the new format automatically
  • Stricter validation: keyVaultNamespace and non-empty kmsProviders are now enforced
  • Named KMS providers (e.g., "aws:account1") are now supported

System Requirements

The minimum OS requirements have been raised due to the Electron 40 upgrade:

  • Windows: Windows 10 or later (64-bit)
  • macOS: macOS 10.15 (Catalina) or later — native builds for both Intel and Apple Silicon
  • Linux: Ubuntu 20.04+ / Debian 11+ / Fedora 36+ (64-bit)
  • MongoDB: Compatible with MongoDB 3.6 through 8.0

For complete migration examples and detailed API changes, see the NoSQLBooster 11.0 Breaking Changes Migration Guide.

Thank you!

Please visit our feedback page or click the “Feedback” button in the app. Feel free to suggest improvements to our product or service. Users can discuss your suggestion and vote for and against it. We’ll look at it too.