Eclipse Theia's maintainers announced version 1.77 on November 19, 2026, bringing a multi-diff editor, more capable secondary windows and changes to its AI agents. The announcement matters to developers who spend much of the day moving between proposed edits and the work those edits affect. It also addresses a second audience, the teams that use Theia to build their own development tools. They face a migration of runtime packages to ES modules alongside the visible additions. Release announcement
The most persuasive part of the update is the attention to work that surrounds generation. A collection of edits has to fit on a screen, a person has to find a change that looks wrong, and an interrupted task has to remain intelligible. An editor can make those moments easier while the model providing suggestions stays exactly as it was. For a team adopting this release, success would mean less effort recovering context and enough confidence in the underlying application to keep reviewing. That outcome calls for testing familiar work through the upgrade, especially in the team's own extensions.
A release has several dates and several users#
November 19 is the date on the public announcement and the release email sent by Jonas Helming. The Eclipse project directory lists November 5 for the 1.77.0 version. A maintainer had also circulated the ES-module migration on November 3, inviting feedback before the broader announcement. The distinction is useful if a team has already tried a preview or built against the versioned packages. Its exposure to the changes may predate the news. This article concerns the November 19 announcement and its implications for work on the 1.77 line. Project version record · Earlier migration notice
There is a similar distinction between using the ready-made Theia IDE and building a product with the platform. The platform supplies a framework for web and desktop tools. The downloadable IDE is one application assembled from it. A person trying that application mostly encounters its commands and controls. A product maintainer also owns the packages, build settings and services around them. The same announcement can therefore represent a small daily convenience for the first person and a substantial dependency change for the second. Theia documentation
Imagine an engineering company with a tailored editor for a device configuration format. Its users may never open an ordinary JavaScript project, yet its maintainers still have to build the editor and connect its own panels to Theia's services. A feature that helps an employee inspect several configuration changes could justify an upgrade. The amount of work depends on how the custom panel behaves when it moves, how it saves data and which assumptions its tests make about the platform. The headline version alone offers little guidance about that particular workload.
This is a useful way to approach an open tool release. Begin with a task the user already performs, then identify the part the platform is changing. A generic demonstration can show the new control. An existing project reveals the controls people rely on while the demonstration is over. Keeping those projects available in an upgrade trial makes the discussion concrete. The maintainer and the user can look at the same change set and describe whether the new view keeps them oriented, even if they measure progress in entirely different ways.
One review surface for edits that belong together#
The multi-diff editor brings a group of changed files into one tab. Added and deleted files are included, and each entry has a collapsible heading. Its editors are loaded as they approach the visible area. The implementation is particularly relevant to an assistant that proposes changes across several files. A person can follow the group without repeatedly opening and closing individual tabs. Multi-diff implementation
Consider a routine rename that touches an interface, a parser and two tests. On a narrow laptop display, a reviewer can spend as much effort moving back to the first file as checking the final one. A continuous review surface makes the relationship between those edits easier to keep in view. It can also make it convenient to pass over an entry after glancing at its header. The useful test is whether the reviewer can still find the precise change that determines correctness, then return to the larger group without losing their place.
For a generated patch, this matters because confidence often rests on a small supporting detail. The code that adds a parameter may look sound while a caller still supplies the old value. A view that puts both files within reach can help the reader ask that question sooner. It cannot establish whether the caller is the only one that matters. Search, tests and an understanding of the code remain part of the work. The opportunity is to reduce the time spent rearranging evidence so that more attention can go to interpreting it.
A fair trial would include a patch with a single change, one with a mixture of new and deleted files, and one with a long generated file that deserves little reading. The person trying the editor can note how quickly they return to an important item and whether they accidentally overlook a collapsed entry. Comparing those observations with their usual workflow is more revealing than timing the first tab opening. The payoff becomes credible when a reviewer can keep the group coherent even after leaving it briefly to inspect another part of the project.
Moving a view changes what closing it means#
The update expands movement between the main window and secondary windows and adds layout restoration. A separate contribution improves the treatment of complex widgets inside those windows. This gives a developer a way to keep a relevant view nearby while working elsewhere. It also gives product maintainers more window states to account for when their own view leaves the main workbench. Window behaviour changes · Complex widget support
An extra display is the obvious setting, although a smaller screen can benefit too. A developer connected to a remote project might place a live preview beside a short source file and switch to a consolidated review view for the final patch. Another developer might keep the command output separate while examining a configuration panel. The desirable arrangement is the one that reduces repeated searching. A window that regularly opens somewhere the user cannot see can undo the advantage, particularly after moving between a desk and a laptop.
Closing behaviour deserves attention because people have learned expectations from many applications. The release provides a preference for moving every view back to the main window when a secondary window closes. Its default closes views, with provisions for state that could be lost. Browser pop-up restrictions also affect what can be reopened at startup. These details make an actual close-and-reopen exercise worthwhile before a team standardises a layout for others. Window preferences and browser limits
A team maintaining a custom panel can make that exercise concrete. Enter a value, leave a result pending and move the panel, then check what appears after closing the secondary window. Repeat with the project reopened. The expected outcome should follow the purpose of the panel. A temporary log might be expendable while an unsaved device configuration demands an obvious route back. A tool that treats both as interchangeable can create a confusing recovery experience. The release creates room for a more useful arrangement, with the application still responsible for making the arrangement understandable.
A shared project brief is easier to maintain#
Theia AI now takes project guidance from AGENTS.md. In a single-folder workspace the root file enters the agents' context, while nested files and multi-root workspaces require relevance-based reading. The change also includes migration from Theia's older project-information template. A repository already using the file for another coding tool has a common place to maintain that part of the brief. Project guidance change
The practical benefit appears when a project has a rule that changes infrequently but is costly to miss. A maintainer might need generated clients updated whenever a schema changes, or a particular directory might require a separate build. Two copies of the guidance can disagree even when both are carefully written. A shared file gives the team one place to correct the rule when a command changes. Its usefulness still depends on keeping the guidance short enough to follow and precise enough for somebody encountering the project for the first time.
This also creates a familiar review responsibility. Project guidance can affect many future changes, so a new instruction merits the same attention as a build-script edit. The interesting question is what a colleague would do with the instruction in an unfamiliar workspace. A sentence that assumes knowledge of a local alias may be unhelpful on a remote host. A command that only runs one part of the test suite may leave an important dependency unchecked. Writing the expected outcome next to the command often makes the instruction easier for people to verify as well.
Multi-root workspaces are a useful place to test the idea. A developer may keep an application and a shared library open together while an assistant edits both. Guidance needs a sensible scope, and the reader needs to know which project a command belongs to. A small task that crosses the boundary can reveal whether the agents find the relevant file and whether the resulting patch respects both projects. The exercise also helps a maintainer remove duplicated or stale instructions. The long-term saving comes from maintaining one accurate brief across the tools the team actually uses.
The model connection is one dependency among several#
The new experimental ChatGPT integration lets a user sign in and choose models available through the subscription. It is supplied through a Theia package alongside the API-key route. For someone who already pays for access, that can make trying the editor less involved. The implementation and its public review describe work on account status, provider choice and session handling, which are the details that decide whether a connection stays usable during ordinary work. ChatGPT integration and review
This is relevant to a team even if it never changes its preferred model. A person can move from a desktop application to a browser-connected development host and discover that the sign-in path matters as much as the editor setting. It is sensible to test with the accounts and environment the team intends to use. The model shown in a selection list, the service entitlement and the ability to resume a real task are related observations. Recording each makes a failure much easier to explain to somebody who has to support the setup later.
The upgrade also changes how several tool calls from one model turn run. Parallel execution is extended across providers through a shared executor. Independent requests can therefore overlap in configurations that previously processed them sequentially. The best case is work with genuine independence, such as gathering information from different sources before preparing a proposal. The application still needs to know which operations can safely proceed together. Parallel tool execution
Imagine an assistant examining several project files while a developer corrects one of them. Finishing the reads sooner can shorten the wait, yet the result has to reflect what was actually read. If an action depends on a preceding action's output, overlapping it changes the task. An upgrade trial can use a few ordinary examples with a known dependency and a few independent reads, then inspect whether the application preserves the intended sequence. The useful measurement is time to a result the developer can accept. More simultaneous activity only helps when that result still carries the right evidence.
ES modules expose assumptions in an extension#
The runtime-package migration is the part an adopter needs to inspect before taking the new interface to users. Theia's packages now declare the ES-module format. The build tooling remains CommonJS, and the migration guide explains how the bundled application can still include CommonJS extensions. The transition therefore depends on which part a maintainer owns and how it is executed. Treating every package as though it were loaded the same way can make a working local build a poor predictor of the shipped product. Runtime migration contribution
Shared dependency imports are one revealing example. The versioned guide tells extensions to use Theia's shared-library exports for dependencies such as inversify. Loading another entry point can produce two copies with incompatible identities. That is the kind of problem a compilation check may fail to expose. A class can have the right name and still arrive from the wrong copy of a library. The natural test is an interaction that actually creates the custom service and uses it through the same path as the installed product. Versioned ES-module migration guide
Module loading also influences tests. A setup routine that used to run before another import may no longer have that effect once evaluation order changes. A maintainer can spend time debugging an apparent product problem that only exists in the test environment, or miss a real issue because the test loads the code in another form. The earliest useful question is where the production entry point and the test entry point begin to differ. Tracing that boundary gives a more focused migration than replacing syntax throughout a repository and hoping the result behaves identically.
For a product team, a staged trial has an obvious economic attraction. First build the existing product with the intended version, then exercise the custom services that matter to its users. Only after those paths behave as expected does it make sense to evaluate whether a new layout or agent setting improves the workday. Otherwise a failed account connection, a panel that loses state and a module-loading issue can all appear during the same demonstration. Keeping a record of the change that introduced each symptom reduces the time spent attributing one layer's behaviour to another.
Compiler and desktop changes have their own scope#
Theia's compiler moves to TypeScript 6. Its migration guide says consumers of emitted declarations can continue using TypeScript 5.9, while teams adopting the newer compiler need to review changes in resolution, ambient types and interoperability. The November article and versioned guide use different wording about module resolution, so a maintainer should examine the configuration shipped with the version they build. The guide for the 1.77.0 tag specifies NodeNext. Compiler migration contribution · Versioned compiler guidance
An explicit compiler choice makes an upgrade easier to discuss across a team. One developer's editor can report a warning that the command-line build does not see if they use different compilers. That discrepancy can turn a straightforward review into an argument about whether a patch is complete. A small reproducible project that exercises a custom extension is a practical way to discover which configuration governs each step. Once the team can reproduce the warning consistently, it can decide whether to change code, configuration or the timing of its compiler upgrade.
Desktop maintainers have another boundary in Electron. The 1.77 announcement lists Electron 44 and an asynchronous clipboard interface, together with a newer native-module compilation requirement. These are reasons to exercise product-specific desktop interactions in the actual package. A form that reads clipboard text and a module built on the developer's workstation can each work in one context and fail in another. The browser version of a tool has different responsibilities at those points. Electron update contribution
A useful rehearsal includes the operations people perform while they are distracted. Copy a value from a debugger, open a project with a non-default layout and stop a task that is still producing output. The time saved by a new review view can be overwhelmed by an everyday operation that stops working once a day. That is why a representative trial does more than make sure the initial screen appears. It follows a small piece of work from opening to completion, including how the person leaves the tool and returns.
The upgrade earns its place during the second task#
For someone trying Theia IDE, a modest evaluation can begin with a patch they already understand. Review it on the screen they normally use, move one relevant view and close the application before returning. The second task reveals whether the layout helps them recover context or requires them to rebuild it. It can also show whether an assistant's guidance and account remain usable after a break. These observations have an immediate connection to the workday and leave room for a fair comparison with the current setup.
For a team building a Theia product, the comparison needs another column for maintenance work. How many custom services required changes? Which tests now represent how the product is actually loaded? Can a colleague rebuild the result without the machine on which the migration was performed? Those answers establish the cost of capturing the benefits. The open platform makes it possible to inspect the implementation and adapt the product. The budget to understand and maintain those adaptations remains with the team that ships it.
A remote development trial should also say where each observation was made. A delayed command might be waiting for the remote host while the browser remains responsive. A heavy diff might make scrolling awkward on one laptop even though its build completes promptly elsewhere. Keeping the two observations separate helps the team decide what to improve. It also makes a report useful to another adopter. A short recording of the interaction, the application version and a small example project can tell a maintainer much more than a claim that remote development is slow. The same discipline is useful when the result is positive, because the next team needs to know which part of the arrangement made the difference.
An independent performance claim would need a workload, a baseline and reproducible measurements. The release materials describe several visible improvements and some internal timings, yet the everyday outcome depends on screen size, project layout, provider and extension set. A team can measure time spent finding the next relevant file, recovery after a window closes and the time to an acceptable agent result. Repeating a few known tasks can reveal more than a broad claim that the editor feels faster, especially when one improvement shortens a wait while another introduces a migration cost.
Theia 1.77 is worth attention because it puts the reviewer's work beside the agent's work. The release supplies more ways to organise a change set and more opportunities to share context across tools. Its broader value will appear when those controls keep somebody oriented during an ordinary, imperfect task. For maintainers, the most convincing result is a product that survives its dependency migration and helps a user pick up the next piece of work with less reconstruction. That is a concrete standard an open development platform can be judged against.