The next version of JVx is right around the corner. We are currently performing some final tests before the release, but it will be ready by early December at the latest!

Version 3.0 was released in December 2024, and a lot has happened since then. JVx itself is very mature and stable despite the low version number. This is also why we have always been in great shape with the nightly builds.

However, since framework security has increasingly come into focus in recent months, we also analyzed JVx more closely. Although we could not find any security vulnerabilities in the framework, we lacked some capabilities to restrict access rights in a fine-grained manner. Therefore, we decided to address this and build in new features - see here.

We have also worked on other areas. You can now define size limits prior to uploading large files. This prevents 200 MB from being uploaded first before receiving information that a maximum of 10 MB is allowed. Furthermore, restricting by file type is now also possible—meaning only jpg or png files should be uploadable, for example.

We also examined the memory consumption of JVx applications under a microscope, as we suspected potential room for optimization. Furthermore, we analyzed a wide variety of production applications to obtain practical values. We were not able to extract as much in this area as expected because JVx was already very well optimized, but we still noticed an improvement in memory release. This also has an impact on application deployment (specifically re-deployment).

For our remote JDBC driver, we packed the UniversalSerializer integrated into JVx into its own archive - it is already available as a separate artifact:

You can find all changes in our Ticket System

In many modern enterprise architectures, developers face the same hurdle: direct TCP/IP connections to the database (via classic ports like 1521, 3306, or 5432) are often strictly regulated for security reasons, blocked by firewalls, or simply undesirable in cloud environments.

To connect Java applications to their data sources nonetheless, teams frequently rely on middleware or specialized protocols. However, existing open-source alternatives often came with compromises - whether through limitations in standards, abandoned projects, or complex integration hurdles. With remoteJDBC, a modern open-source solution is now available that enables JDBC communication seamlessly and straightforwardly over HTTP(s).

Existing Alternatives at a Glance

Those who previously needed to connect databases via HTTP or remote setups typically encountered a few well-known options, each with its own limitations:

• OJP (Open-J-Proxy): A fully open-source project that works very well, but standardly requires its own server process and an additional port. While an extension exists to enable HTTP(s), it is not tightly integrated into the core project, and incorporating it into custom applications often requires numerous additional dependencies, which can easily lead to version conflicts.
• Apache Calcite / Avatica: A powerful framework, but in the realm of JDBC, it often covers only a subset of the standard and thus does not universally address all requirements.
• AceQL: Offers a working HTTP-based JDBC connection, but the server-side component is tied to a commercial license (not for all database systems) and number of "database names". This restricts its use in pure open-source or cost-free projects.
• VJDBC: A historically well-known approach for remote JDBC, but it has not been actively developed for many years and lacks modern Java standards and security features.
• RazorSQL JDBC Bridge: A commercial product which comes with RazorSQL and has limitations.

The remoteJDBC project sets out to solve precisely these friction points.

What is remoteJDBC?

remoteJDBC is an open-source driver by SIB Visions designed to bridge the gap in HTTP-based database communication. The project's goal is to provide a broad and practical implementation of the JDBC standard over HTTP(s) - consistently under the GPLv3 to safeguard the true open-source ethos.

The approach allows you to retain your familiar JDBC code in Java applications, while SQL queries and results are securely transmitted in the background using a standardized HTTP protocol.

The Highlights: Feature Set in Detail

In daily use, the driver scores points with thoughtful technical characteristics that go far beyond a simple forwarding proxy:

• HTTP(s)-Native Communication: Directly utilizes standard web infrastructure. Firewalls, proxies, and load balancers that allow web traffic are passed through without issue - requiring no special VPN tunnels or the opening of sensitive database ports.
• Prepared Statements & Parameters: Supports not only simple SQL queries but also parameterized
  PreparedStatements for secure and performant execution.
• Transaction Management: Enables the familiar control of transactions (including commit and rollback) to ensure data consistency across the HTTP boundary.
• Metadata Processing: Provides support for DatabaseMetaData and ResultSetMetaData, which is especially vital for ORM frameworks or generic dataset applications.
• Lean Dependencies: Unlike complex proxy solutions, remoteJDBC is structured to integrate cleanly into existing projects without unnecessary overhead or the risk of version conflicts.
• Consistent Open Source (GPLv3): Full transparency and freedom in the source code, ideal for projects that actively support and live the open-source philosophy.

Who is remoteJDBC for?

The driver is particularly interesting for:

• Cloud and Container Architectures, where direct database connections across network boundaries should be avoided.
• Applications in Restricted Networks, where exclusively standard web ports (80/443) are open.
• Projects with Minimal Dependencies, seeking a clean and straightforward integration without excessive ballast.
• Scenarios Involving Communication Between Virtual Machines (VMs) that need to communicate via JDBC over standardized protocols.
• Developers and Architects looking for a performant, open-source alternative to proprietary middleware solutions.

Outlook and Contributing

Since the project is hosted as open source on GitHub, it thrives on community feedback and contributions. If you are looking for a flexible way to address databases over HTTP and want a clean alternative to commercial tools or complex proxy setups, it is well worth a look:

remoteJDBC @ GitHub

Try out the driver, test it in your scenarios, and feel free to leave feedback or issues on GitHub to actively support us!

In software development, two different worlds often clash: On one side are slow, complicated enterprise processes; on the other, modern cloud tools promise fast results, but quickly fail when facing complex business needs.

Particularly for Java developers and IT teams in the mid-market, the question arises: How can development time be drastically shortened without losing control over architecture, security, and the actual Java code?

A look at an alternative approach shows what a bridge between visual development, a robust Java basis, and flexible infrastructure can look like.

1. Why a Desktop GUI Designer Makes Sense in Professional Environments

While the trend in the no-code sector points almost exclusively to purely browser-based interfaces, professional software development offers weighty reasons for a different approach. A local, native desktop designer brings specific characteristics:

• High Performance Without Browser Limits: Complex, data-intensive enterprise masks can be edited fluidly in a desktop application without performance drops caused by latencies or browser RAM limits.
• Full Offline Capability: Developers can work undisturbed regardless of a stable internet connection - whether on a train or in secure environments.
• Full Control: The code remains locally accessible and can be seamlessly linked with familiar IDEs like IntelliJ or Eclipse, rather than gathering dust in a pure cloud sandbox.

2. The Java Basis: Full Control and Direct Code Access

Classic low-code platforms often work with rigid generators or hidden black boxes where code must be laboriously exported to make adjustments. Here, it works differently:

• Real Code as a Living Basis: There is no separate export step. The platform works directly on the actual Java code, which is changed and adapted live.
• The Strength of the Java World: Instead of proprietary scripting languages, mature Java technologies are used. Existing libraries, frameworks, and internal corporate Java components can be easily integrated and controlled directly within the code workflow.

3. One Backend, Three Frontends: React, Flutter, and Vaadin

Projects today demand flexibility: Sometimes a modern web application is needed, other times a native mobile app for field staff, or a classic enterprise mask.

• Centralized Logic: Business logic and data structures are defined once in Java.
• Multichannel Output: From this, the system seamlessly serves modern React web interfaces, native Flutter apps, or proven Vaadin views.

This eliminates the need to build a completely separate development team for every single device type.

4. Flexible Deployments: From Docker to Classical Application Servers

Corporate landscapes are heterogeneous. While some companies consistently rely on containers, many established institutions have successfully worked with proven infrastructures for years.

• Freedom of Choice in Hosting: The platform is not tied to a mandatory Docker environment. It can be operated either via modern Docker containers (cloud or private cloud) or deployed seamlessly on classical enterprise application servers within existing data center architectures.
• Maximum Compatibility: This allows the software to fit smoothly into the already existing system landscape without requiring existing operating concepts to be overhauled.

Conclusion

There is no single way to build software. Whether browser or desktop, low-code or hard-code, Docker or application server - what matters is that the architecture fits the use case. Combining the robustness and openness of directly modifiable Java code with the speed of visual design tools and flexible deployment options creates a pragmatic alternative for demanding enterprise software.

We make all of this possible with VisionX.

In modern enterprise software engineering, two major bottlenecks frequently slow down innovation: platform fragmentation across devices and vendor lock-in caused by proprietary low-code engines. Developers often find themselves maintaining separate codebases for web, mobile, and desktop applications, while being unable to leverage modern AI tools due to black-box platforms.

This is where VisionX changes the paradigm. Designed as an open, Java-based low-code application development platform, VisionX allows engineering teams to visually design data models, UIs, and business logic once - and deploy them seamlessly across Web, Mobile, and Desktop.

Cross-Platform UI Without Code Duplication

Unlike conventional rapid development tools that output fragile, proprietary runtimes, VisionX leverages a clean separation between application logic and rendering engines. This design philosophy enables true multi-platform output from a single application model:

• Web Applications: Deploy highly responsive enterprise web portals and back-office tools running on standard web frameworks and HTML5/CSS standards.
• Mobile Apps: Provide field workers and mobile users with responsive, touch-optimized interfaces designed specifically for iOS and Android devices.
• Desktop Clients: Deliver high-performance, rich desktop interfaces for complex data entry, heavy multi-window workflows, and deep local peripheral integrations.

Clean Code & Pure Data Models: Supercharged by AI

A primary differentiator of VisionX is what happens under the hood: instead of generating proprietary metadata, VisionX outputs clean, standards-compliant Java source code and structured relational data models. Because there is zero hidden magic or black-box lock-in, your application codebase is fully accessible and human-readable.

This architectural transparency makes VisionX applications uniquely suited for AI-assisted development:

• Compatibility with Any AI Platform: You can plug generated VisionX Java code into any LLM or AI coding assistant - such as OpenAI, Anthropic Claude, GitHub Copilot, Cursor, or local LLMs.
• AI-Driven Business Logic: Developers can use AI prompts to generate complex algorithms, data transformations, or custom business logic in pure Java, then instantly plug them into VisionX Actions.
• Clean Schema Reasoning: AI tools easily understand VisionX data models, enabling automated SQL optimization, automated unit test generation, or instant REST API extension.

Unrestricted Architecture: Ecosystem & Cloud Flexibility

Instead of forcing developers into a single closed cloud ecosystem, VisionX natively integrates with any modern technology stack, cloud provider, or deployment model.

1. Modern Serverless Backends (Supabase & Neon)

VisionX apps connect directly to modern PostgreSQL ecosystem powerhouses. Whether leveraging Supabase for real-time APIs, built-in storage, and row-level security, or Neon for instant database branching and auto-scaling serverless storage, VisionX treats these state-of-the-art backend layers as standard, first-class SQL data sources via standard JDBC drivers.

2. Containerization & Orchestration (Docker & Kubernetes)

Because applications built in VisionX compile down to standard Java application architectures, containerization is straightforward. You can package VisionX backends into lightweight Docker containers and orchestrate them via Kubernetes, OpenShift, or any public cloud container service (AWS ECS, Azure Container Apps, Google Cloud Run).

3. On-Premise & Legacy Databases

Enterprise realities often demand hybrid approaches. VisionX bridges modern cloud infrastructure with existing legacy infrastructure. It connects out of the box to enterprise database management systems including Oracle, MS SQL Server, DB2, MariaDB, and standard PostgreSQL or EDB instances.

Why Engineering Teams Choose VisionX

• Zero Vendor Lock-in: Applications are built on open-source Java standards. You retain complete ownership of your generated source code.
• Bi-directional IDE Sync: Work visually in VisionX while changes automatically synchronize in real time with Java code in Eclipse or your preferred IDE.
• AI-Ready Developer Workflow: Combine visual low-code speed with AI without running into black-box platform limitations.
• Rapid Time-to-Market: Prototype, iterate, and roll out complex enterprise features in days rather than months, across all target platforms simultaneously.

Conclusion

Developing enterprise applications across web, mobile, and desktop no longer requires maintaining disconnected development teams or taking on massive technical debt. By pairing VisionX's multi-platform UI generation with clean Java code output, AI development tools, and modern backends like Supabase, Neon, and Docker, organizations build flexible, future-proof software systems that adapt to any technical ecosystem.

In modern software development, low-code and rapid-application-development platforms often face a critical architectural choice: how to maintain exceptional speed in creating user interfaces and business workflows without encountering severe bottlenecks in database infrastructure and scalability.

This exact intersection is where VisionX excels. As a platform that combines rapid visual development with full Java compatibility and open standards, VisionX benefits immensely from modern, cloud-native database architectures like Neon.

Why Database Infrastructure Matters for VisionX

VisionX empowers development teams and enterprise architects to design business applications, data models, and complex integrations visually while seamlessly generating clean, maintainable code underneath. By default, VisionX relies on proven relational database systems, with PostgreSQL serving as one of its primary production standards.

However, to fully capitalize on the agility that VisionX delivers, the underlying database environment must keep pace. Integrating Neon as the PostgreSQL database layer resolves traditional administrative hurdles and provides concrete operational advantages directly within the VisionX development lifecycle.

1. Seamless Prototyping & Instant Environment Branching

In VisionX, data models, business logic (Actions), and visual UI components are developed hand in hand. When features are updated or relational structures are refactored, testing requires reliable, isolated data environments.

• The VisionX Advantage: Neon's Copy-on-Write Database Branching allows instant cloning of PostgreSQL databases via API within milliseconds. Prior to deploying schema changes or testing new VisionX workflows, developers can branch the production database state. Teams test new VisionX applications against realistic data structures without risk to production or time-consuming manual database dump/restore cycles.

2. Resource Efficiency Across Multi-App Portfolios

Enterprises frequently use VisionX to build vast portfolios of specialized internal tools, operational dashboards, and micro-applications. Operating dedicated, always-on database instances for every minor utility quickly drives up operational costs.

• The VisionX Advantage: Thanks to Neon's Scale-to-Zero compute capability, databases for rarely accessed or off-hours VisionX applications automatically suspend when inactive. The moment a user accesses the VisionX frontend, the database compute instance resumes within milliseconds. This enables organizations to host dozens of specialized VisionX utilities at minimal infrastructure cost.

3. Resilience Under Peak Load & Serverless Patterns

VisionX applications process high-throughput data operations and expose automated REST interfaces. During heavy concurrent user access or automated batch processing, legacy PostgreSQL configurations often face connection exhaustion.

• The VisionX Advantage: Neon's built-in connection pooling handles spikey, concurrent query flows from VisionX smoothly. The application maintains predictable performance and connection stability without requiring complex external proxy management.

Architecture Overview: VisionX + Neon

+-------------------------------------------------------+
|                   VisionX Platform                    |
|  (Visual Designer, UI Components, Actions, REST API)  |
+-------------------------------------------------------+
|
(Standard JDBC / PostgreSQL)
|
+-------------------------------------------------------+
|                         Neon                          |
|  * Copy-on-Write Branching (Instant Test Databases)   |
|  * Auto-Scaling & Scale-to-Zero (Cost Optimization)   |
|  * Built-in Connection Pooling (PgBouncer-level)      |
+-------------------------------------------------------+

Key Benefits for Engineering Teams

Integrating Neon reinforces core VisionX principles: uncompromised speed, enterprise stability, and zero vendor lock-in.

• Zero Infrastructure Overhead: Engineers stay focused on modeling business logic and UI layouts in VisionX rather than provisioning and managing physical database instances.
• Accelerated CI/CD Pipelines: Automated deployment pipelines for version-controlled VisionX projects pair naturally with instant database branching.
• Full Native Standard Compatibility: Because Neon delivers 100% PostgreSQL compatibility, VisionX connects using standard JDBC drivers and standard SQL queries without requiring custom drivers or proprietary connectors.

Conclusion

For organizations engineering enterprise solutions with VisionX, Neon offers an ideal PostgreSQL foundation. By eliminating operational friction around provisioning, branching, and scaling relational databases, the combination ensures that database management remains as agile, flexible, and efficient as VisionX itself.

We are always looking for good solutions that can be used together with VisionX. A product like Supabase is definitely one of them.

Supabase is an open-source alternative to Firebase. It is a Backend-as-a-Service (BaaS) that provides developers with all the necessary backend functionalities to quickly build modern web and mobile applications without having to manually manage servers.

Key Features

• PostgreSQL Database
• Authentication
• Real-time Updates
• Auto-generated APIs
• Storage
• Edge Functions

You can find the source code on GitHub, and the Docker-Compose files are also ready to go.

However, we tried the online version and simply registered for the Free Plan. The registration is very easy, and you are ready to go in 2 minutes. After registration, you simply create a new application with VisionX and connect it to the database using a custom data source.

The most complicated part was finding the URL. In our case:

Supabase connection

After the Supabase connection was configured, VisionX could be used as usual. We created a person mask for entering first name, last name, date of birth, and description. This was a simple test mask without any complex logic.

We then tested the features of the Supabase interface (creating new columns, modifying data, creating data models, REST API) and found no problems. Supabase is a practical solution, especially for VisionX applications.

The only thing that could be improved is the table editor, because when editing a column, you have to keep the focus on the editor before pressing ENTER to save; otherwise, the original value is saved. However, this might actually be intended

Of course, we could also install it as a web application as usual:

VisionX application

We spent about 60 minutes with Supabase and were able to utilize all features of VisionX fully. The logging features and statistics provided by Supabase are particularly handy.

Our conclusion: VisionX and Supabase are a match!

On August 12, Flutter 3.47 was officially released, bringing a wave of exciting changes and brand-new features.

We always strive to keep our Flutter client as up to date as possible, so we took the plunge and upgraded early. Even though not all add-ons have been updated by the community yet, our client is running quite well. We did have to patch a few AddOns ourselves, but the community will certainly release updates in the coming weeks.

Here are the add-ons we have updated and patched so far:

• Action Slider
• Flutter TreeView
• HTML Editor Enhanced

In our testing so far, we didn't encounter any limitations or major issues.

We would love to hear your thoughts.
Have you made the switch to 3.47 yet, or are you waiting for specific packages to update?

Our VisionX App v3.4.0 has officially landed in the app stores. Over the past few weeks and months, we have poured a ton of energy into feature development, and it has truly paid off. With the new release, building sleek, custom applications is easier than ever. We put together a quick video to show you what we mean.

In the video, you will see a password management app built with 3 core screens: Secrets, Security Protocol, and Feedback.
The entire application was built and deployed with VisionX in just 20 minutes.

The first 30 seconds of the video show the menu and Secrets screen in their raw, out-of-the-box state. The app is fully functional right away, but there is plenty of room for visual polish - and that is where the magic happens starting at second 31.

First, we drop the header background color and hide the menu grouping, since small apps do not really need category groups anyway. Next, we update the global application color, which instantly propagates across all screens including Secrets.

Since the Secrets screen has its own header background, we clear that as well. By default, it features a search field, a button, and a data table. To save screen real estate, we convert the label into a sleek placeholder text with a magnifying glass icon, then align the search button directly beside the field. While tables are useful, a card-style list fits sparse data much better, so we swap the table for a list, color-code alternate rows for readability, and add dynamic icons.

The result is a clean, modern aesthetic that looks infinitely better.

Next up: the input form. Originally, it takes a traditional approach with standalone labels, input fields, and standard action buttons. Works fine, but with room for visual improvement. To modernize it, we integrate labels directly into the fields as placeholders, remove full button borders for a subtle look, and add a live password strength meter. We also tweak the required field color so it blends seamlessly with the new theme, and finish off with a clean border frame around the image.

The application now feels completely redesigned, fresh, and polished.

The absolute best part?

No rebuilding or new app deployment was required - just pure styling updates. The app dynamically adapts to whatever configuration you define.

For instance, switching from a table to a customized list is done in a single line:

With just three simple calls:

you refine the search bar by adding an inline search icon, setting placeholder labels, and docking the button inline.

To activate the dynamic password strength bar:

And to frame images cleanly:

Menu adjustments are handled directly in mobile_styles.xml:

And the list styling comes together with:

In just 10 extra minutes of styling, you can transform any application to match your exact brand vision and deliver tailored user experiences.

We rely on these features every single day.

More styling options are available in our documentation.

Digital connectivity brings immense value, but it also demands a new level of protection. With the EU Cyber Resilience Act (CRA), the European Union is setting strict standards for reporting security incidents and vulnerabilities starting September 11, 2026. The good news for our customers and partners: We have completed our preparations early.

We have established all necessary processes and structures to fully comply with the CRA requirements going into effect in September 2026.

What does this mean for you in practice?

• Real-time transparency on vulnerabilities: Should critical security gaps be identified or actively exploited in our products, our newly structured reporting and analysis processes take effect immediately. We will inform the relevant authorities (such as ENISA) within the required deadlines.
• Rapid patch management: Thanks to the direct integration of our vulnerability management with early warning systems, security updates will be fed into our development pipeline even faster.
• Proven resilience: Our internal organization has been adapted to the new EU regulations - ranging from incident tracking to a clear incident response chain.

Looking ahead: Our roadmap to 2027

The CRA is not a one-time project, but an ongoing standard. While the September 2026 milestone focuses on reporting mechanisms, we are already working behind the scenes on the next phase for December 11, 2027

We are excited to roll out VisionX 6.6.601.

This update packs a punch, bringing significant upgrades to our Mobile App and Next-Generation Web experience, alongside essential platform refinements, cloud efficiency gains, and key developer fixes.

Whether you are building cross-platform enterprise apps or fine-tuning existing layouts, version 6.6.601 delivers a smoother, faster, and more customizable developer journey.

Here is a breakdown of everything new in VisionX 6.6.601

Mobile App: Advanced Security, Richer UI & Better Customization

The VisionX Mobile experience gets a huge leap forward with security features, expanded UI components, and flexible styling tools.

• On-Device Data Encryption

  Local data is now automatically encrypted prior to storage on the device.

• Biometric & PIN Security (Optional)

  Enable Face ID, Fingerprint, or PIN protection for secure app access.

• Multi-Factor Authentication (MFA)

  Native support for MFA workflows straight out of the box.

• Encrypted Data Export (HTML Safe)

  Export encrypted device data directly on the device in a secure format.

• UI Styling

  Extended styling customization across menus, buttons, tables, and form components.

• Brand-new Button Group control
• Brand-new Password strength control
• Foldable group panels
• Modern Tabset component
• Direct access to all FontAwesome and Material Design Icons
• Optional Copy-to-Clipboard button inside text editors
• Optional Show-password button inside password editors
• Image manipulation for image editors
• Contextual visual indicators/markings for empty menus and empty tables
• Display small arrows if more records are available within table views
• Configure image quality and size in settings

Web (Next Generation): Speed, Precision & Smooth Workflows

Our Next-Gen Web platform gets performance enhancements and UI improvements designed for high-data volume applications.

• Sticky Table Headers

  Table headers now stay fixed at the top while scrolling through long rows of data.

• Redesigned Signature Pad

  Rebuilt from the ground up for reliable, smooth digital signature capture across devices.

• Improved Lazy Loading
• Image Choice Editor Fixes

  Resolved display and rendering glitches for images inside image choice editor.

Core Platform & Developer Experience

We have introduced handy quality-of-life enhancements and platform optimizations to speed up daily design workflows.

• Finer Spacing Controls

  Granular horizontal and vertical layout control between labels, editors, and panels.

• Security Protocol (AddOn)

  A dedicated Security protocol is now available as an AddOn for audit-heavy environments.

• Directory Switching

  Switch application directories directly within VisionX without leaving the tool.

• Cloud Footprint Reduction

  Memory optimization reducing RAM consumption for cloud-hosted deployments.

• Localized Module Setup

  Module installations now seamlessly respect system translation tables.

• Streamlined Documentation

  Module documentation is automatically provided directly in the /doc directory.

• External File Change Alerts

  The Action Editor now alerts you immediately if files have been modified externally.

• Mobile Engine Support

  Native support aligned with the latest mobile app builds.

Key Bug Fixes & Stability Improvements

This update addresses critical feedback from our developer community!

• Anchor Positions

  Fixed input issues with anchor positions in the Designer.

• Multi-Module Integration

  Resolved a bug where only one module was integrated in the Designer instead of all selected modules.

• Application Import

  application.xml settings are now properly preserved when importing applications.

• Combobox Column Renaming

  Resolved an issue where Combobox table columns could not be renamed.

• Live Preview Accuracy

  Live Preview now instantly reflects newly created reports and newly added tables in existing screens.

Ready to Upgrade?

VisionX 6.6.601 is available in the download area!

Download the update to take advantage of the new web & mobile components and performance enhancements.

Our mobile app will be available in the stores within the next few weeks!