Forem: Nacho Codoñer

Meteor 3.4 is out: Rspack integration, 4x faster builds, 8x smaller bundles, and extended bundler features

Nacho Codoñer — Fri, 30 Jan 2026 15:35:58 +0000

Meteor 3.4 marks the final day of the Galaxy Expansion and celebrates a new era for the framework that started it all, bringing modern tools into the core Meteor experience.

Meteor 3.4 introduces the Rspack bundler in the core to improve the dev experience by cutting build times, reducing bundler size, and supporting standard configuration patterns and features from the wider JS ecosystem.

This is a big step forward to address many long-requested improvements Meteor users have talked about, and we moved toward them across the newer Meteor 3 era.

In Meteor 3.2, we started by adding tools to monitor our goals for the build experience, with meteor profile introduced to measure build times and bundle size.

In Meteor 3.3, we delivered the first round of optimizations for faster builds on the Meteor bundler, getting more from the solid and mature mechanism used for Meteor apps since the beginning. We added a new transpiler with SWC, a new watcher, and other improvements.

In Meteor 3.4, to wrap up this effort on improving the bundler experience, we focused on delegating to a modern tool like Rspack, which let us meet all initial goals and allow Meteor apps to apply efficient HMR, tree shaking, full ESM support, modern plugins, and more.

Our core team has already migrated to Rspack for the Galaxy Cloud app, showing the optimizations applied to a real-world app like the one hosting your Meteor apps. This post details the changes and shows the Galaxy app’s improvement metrics as an example of what to expect with your Meteor 3.4 upgrade when adopting the Meteor Rspack integration.

This release also includes community contributions for Meteor React packages by improving stability and performance of suspense hooks, integrating collection-extensions package into core, considering Cordova as a modern build, and more.

Getting Started

To start using Meteor 3.4.

Create a New App

# Create a new Meteor app using Meteor 3.4
meteor create my-app --release 3.4

All improvements introduced in Meteor 3.3 and 3.4, including the Rspack integration, are enabled by default for new apps and applied to all skeleton examples. Check meteor create --help to see the available skeletons.

Update Your App

# Update your existing Meteor app to version 3.4
meteor update --release 3.4

Add modern to your package.json to enable the Meteor Bundler optimizations:

"meteor": {
  "modern": true
}

Check out the requirements for Meteor Bundler optimizations on existing apps.

☄️Meteor Bundler optimizations docs

Add rspack package to enable the Rspack Bundler integration:

meteor add rspack

Check out the requirements for Rspack Bundler integration on existing apps.

⚡Rspack Bundler integration docs

Highlights

Faster Builds

Meteor 3.4 goes further than Meteor 3.3 and the initial SWC adoption. With Rspack now compiling your app code, you get the speed of this modern tool built in Rust. The Meteor bundler still compiles Atmosphere packages and links the final app code, but that part was already optimized in Meteor 3.3, so you get the best of both.

With meteor profile, build times drop ~70% and are over ~3.5x faster. Rebuild times for both client and server are now much shorter, making development far quicker.

These metrics were measured for the Galaxy app Rspack migration, coming from Meteor 3.3 applied optimizations. Your app will see similar improvements.

Smaller Bundles

Meteor 3.4 introduces one of the most awaited features to keep app bundles small: tree shaking. With the Meteor-Rspack integration, bundle size is significantly reduced through this built-in optimization, along with other Rspack strategies such as chunk splitting, dynamic imports, minification and more.

After migrating and deploying the Galaxy app, the main client bundle size dropped by about 88% compared to previous 3.3.2 release. Client bundles are now thinner, meaning less code delivered and faster initial load times for your apps.

The gains vary by app, its dependencies, and the optimizations used. Just by applying tree shaking you will get improvements; sometimes smaller, sometimes much larger, depending on how tree-shakeable your dependencies are.

Additionally, by using code splitting and dynamic imports you split the main chunk, reduce the main size, and load other pieces on demand. Give it a try and play with these options in your project.

Atmosphere Bundle Reduction

What is more, Meteor 3.4 adds an optimization for Atmosphere packages by introducing:

The ability to mark packages as devOnly, so they’re fully removed from production builds.
A new Npm.devDepends option in your package.js to define dev dependencies, ensuring only the needed node modules for development are included during dev time and excluded from production (meteor build).

After deploying the Galaxy app, the total bundle size stored on the host machine dropped by about ~42%. This improvement applies to all apps, since Meteor core packages now use the new Atmosphere optimization configuration. More gains will come as you update your own Atmosphere packages or community ones to properly skip dev-only packages and dependencies in production builds, leaving your final containers on hosts noticeably smaller.

Modern Setups

Meteor 3.4 introduces Rspack so you can configure modern setups from the community.

Supported setups include React, React Compiler, Vue, Solid, Svelte and Angular, all using their latest versions. Legacy setups like Coffeescript and Blaze remain supported, keeping older projects compatible.

With this update, ESM packages are fully supported. Meteor apps can now use modules that rely on ESM behavior. A clear example is the support for React Router v7, a long-standing request from the community.

Rspack also opens many new options. All Rspack or Webpack features can be configured in Meteor apps, including Workbox for Service Workers and PWA, asset imports and optimizations, and controlling the bundler lifecycle for custom behaviors and improvements.

What Else Is New in Meteor 3.4?

Thanks to the commitment of many of our community contributors, we have been able to expand this release with new features and optimizations.

react-meteor-data updated to 4.0.1, bringing improvements to suspense hooks and general optimizations. @welkinwong, @malua, @evolross, and @StorytellerCZ delivered these updates along with other maintenance.
Integrated collection-extensions into core, part of our goal to bring widely used packages across Meteor projects into core for better support and maintenance. Thanks to @harryadel for making this possible.
Cordova builds are now considered modern instead of legacy when "modern": true is set in your project’s package.json. @tmeyer24 prepared this change, laying the groundwork for future native updates with CapacitorJS or similar modern tools.
--raw-logs is now the default in the Meteor CLI for development. @paulishca suggested this, with full consensus from the community, and @Grubba27 provided the update quickly.

More improvements and fixes were introduced in Meteor 3.4, see the changelog.

For more insights into the release, watch the release video:

📹 Meteor 3.4 and the road ahead - Galaxy Expansion Day 5.

For more about the modern build stack, including Rspack, we joined Meteor Impact and gave a talk that explains its adoption, migration, and expected benefits.

📹 Modern Build Stack in Meteor 3: Empower Your Meteor Apps with Faster, Feature-Rich Bundling

Big Thanks to our contributors

Reaching the 3.4 milestone would not have been possible without such an active and enthusiastic community. We want to highlight how important these contributions have been for this release.

Thanks to our core contributors: @nachocodoner, @italojs, @Grubba27, @welkinwong, @harryadel, @vparpoil, @StorytellerCZ, @turoar23, @DipakHalkude, @sanki92, @evolross, @malua, @tmeyer24, @jeetburman and @copleykj

Thanks to all community members for the testing and feedback on Meteor 3.4.

What’s Next for Meteor and Beyond?

For the upcoming releases, we have the following priorities.

Stability and patches. Collect feedback and fix issues. Planned Meteor 3.4.x patches.
Change streams. Unified MongoDB change notifications. Planned on Meteor 3.5 release./
Node 24. Align with newer Node LTS releases.
Native. Move toward a modern native solution beyond Cordova.

For more details on upcoming work and priorities, see the Meteor roadmap.

Join the Meteor Renaissance!

Meteor 3.4 wraps up the significant bundler changes we had envisioned. From these changes we will keep tweaking the bundler to expand and improve the experience if needed. Still, we’ll continue updating Meteor to revitalize the framework we all love in other areas as well.

We’re excited about what’s to come and can’t wait for you to join the Meteor renaissance!

For feedback, questions, or support, visit our forums or join our Discord channel.

If you find any issues, please report them to the Meteor issues tracker.

Stay tuned, and as always, happy coding! ☄️

Faster Builds in Meteor 3.3: Modern Build Stack with SWC and Bundler Optimizations

Nacho Codoñer — Tue, 17 Jun 2025 14:41:26 +0000

Meteor 3.3 slashes build times by around 60% on average, with some projects building over 3× faster builds.

This is the first major update to the Meteor bundler in years, introducing several optimizations. The main change is switching from Babel to SWC for transpiling and minifying to speed up builds. We reviewed and optimized the bundler’s components to improve the development experience.

On our core team, we’ve already seen these gains after upgrading the Galaxy Cloud app, and the cloud team’s development and delivery have become significantly faster. This post details the changes and shows the Galaxy app’s improvement metrics as an example of what to expect with your Meteor 3.3 upgrade.

This release also includes community contributions for Meteor React packages, improving stability and performance of common hooks and adding support for React 19.

Getting Started: A Quick Hands-On

To start using Meteor 3.3.

Update Your App

# Update your existing Meteor app to version 3.3
meteor update --release 3.3

Create a New App

# Create a new Meteor app using Meteor 3.3
meteor create my-app --release 3.3

Add this to your package.json to enable the new modern build stack:

"meteor": {
  "modern": true
}

This setting is on by default for new apps.

Highlights

Modern Build Stack

Meteor 3.3 brings a new build stack: SWC for transpiling and minifying, @parcel/watcher for file watching, and smarter skips for legacy bundles.

Turn on "modern": true in your package.json and see rebuilds and builds fly!

On average, build and rebuild times are cut by about 60%, roughly a 3× speed-up.

These results come from the Galaxy Cloud app. In the next sections, we break down improvements for development and production experiences. Your app’s numbers may differ, but you can expect similar gains.

Curious about the gains? Run meteor profile to compare Meteor 3.2 vs 3.3 on your project and share your results!

Development Breakdown

When running meteor run, timings from meteor profile in Meteor 3.2 vs 3.3.

On average, these runs show about a 60% reduction in build times, corresponding to roughly a 2.7× speed-up, and exceeding 3× in many cases.

Production Breakdown

When running meteor build, timings from meteor profile --build with and without "modern": true.

On average, these runs show about a 60% reduction, corresponding to roughly a 2.5× speed-up.

Build Stack Upgrade

Transpiler

The transpiler converts modern JS syntax in all app code to a cross-browser compatible version.

Meteor profiling showed most build time goes to Babel transpilation (meteor run/meteor build). To fix this, we added SWC (in Rust), which speeds up rebuilds in both development and production.

There are no breaking changes for most apps. If your app uses nested imports (not dynamic ones), it may fall back to Babel. The same applies if you use Babel plugins that SWC does not support yet. You can find SWC equivalents or disable SWC for those files.

We also added a doc page with tips for migrating and debugging the new setup.

🔗 Modern Transpiler: SWC docs

Minifier

The minifier reduces and obfuscates your app’s production bundle for security and efficiency.

Meteor profiling showed Terser spends a lot of time on production builds (meteor build). To fix this, we added the SWC minifier, which speeds up builds.

@italojs adapted the minifier from the zodern/minify-js-sourcemaps package, cherry-picked it, and integrated it into Meteor core, delivering the performance gains we wanted.

🔗 Modern Bundler: Minifier docs

Web archs

Web archs are the builds Meteor generates for modern browsers, legacy browsers, and Cordova.

Skipping web.browser.legacy and web.cordova speeds up builds. In development mode, Meteor skips these archs when they aren’t needed.

Thanks to @9Morello for driving this forward!

🔗 Modern Bundler: Web Arch docs

Watcher

The watcher listens for changes in your app’s code files and triggers quick recompilations.

Meteor now uses @parcel/watcher. This improves development mode speed and compatibility by using native, recursive file watching on all OS. It also fixes a long-standing Linux delay where file changes took 5 seconds to register.

🔗 Modern Dev Server: Watcher docs

Tools: CPU profiling

Observability is crucial for data-driven releases. In our effort to enable this, we’ve improved our profiling tools and made them available to everyone.

We added environment variables to generate and inspect CPU profiles. In his guide, @italojs shows how to run these profiles and pinpoints Babel as a bottleneck now replaced by SWC in 3.3.

We enhanced the meteor profile command introduced in Meteor 3.2. It now includes a --build flag to profile the production build and highlight minifier gains. Rebuild reports now emphasize total rebuild times so you can track client and server build improvements.

React 19 Support

We updated the meteor/react-packages repo to restore tests/CI and ensure compatibility with Meteor 3. Contributors also improved the performance of useFind and useSubscribe, and added React 19 support.

Try the new beta of react-meteor-data:

meteor add react-meteor-data@4.0.0

Thanks to @welkinwong, @Poyoman39, and @PedroMarianoAlmeida for their contributions and tests!

Be aware of a breaking change: useFind describes no deps by default #431

What Else Is New in Meteor 3.3?

For full details on what’s included in Meteor 3.3, see the changelog.

For more insights into the release, watch the release video.

We want to highlight how important community members contributions have been in delivering these changes.

Thanks to our core contributors: @nachocodoner, @italojs, @Grubba27, @zodern, @9Morello, @welkinwong, @Poyoman39, @PedroMarianoAlmeida, @harryadel, @ericm546, @StorytellerCZ.

Thanks to community members for testing and feedback on Meteor 3.3: @zodern, @minhna, @paulishca, @pmogollon, @ferjep, @wreiske, @schlaegerz.

What’s Next for Meteor and Beyond?

For the upcoming releases, we have the following priorities.

Stability and patches. Collect feedback, fix missing support or issues in modern build stack, and ship pending contributions. Planned Meteor 3.3.x patches.
Modern bundler. Integrate a bundler that meets current standards for performance, tooling, plugin support, and community growth. Planned for Meteor 3.4. A demonstration is available, please share your feedback on the Meteor-RSPack integration.
Change streams. Provide a unified API for MongoDB change notifications to improve efficiency and consistency. Research is underway, please share your feedback: MongoDB Change Streams support in Meteor.

To learn more about upcoming work, see the Meteor roadmap.

Join the Meteor Renaissance!

Meteor 3.3 delivers significantly faster build times for your Meteor app development experience. These changes are just the beginning; we’ll continue updating Meteor to revitalize the framework we all love.

We’re excited about what’s to come and can’t wait for you to join the Meteor renaissance!

For feedback, questions, or support, visit our forums or join our Discord channel.

If you find any issues, please report them to the Meteor issues tracker.

Stay tuned, and as always, happy coding! ☄️

Unlocking Meteor 3.2: New Profiling Tool to Track Bundler Performance and Size

Nacho Codoñer — Thu, 20 Mar 2025 16:37:38 +0000

Meteor continues to evolve. After focusing on improving runtime performance, the latest update, Meteor 3.2, pivots toward bundler performance and optimizing the developer experience.

With Meteor 3.2, we introduced profiling. We revisited the old implementation to restore functionality and added meteor profile for automatic analysis of the app build process. This tool helps you track critical data like build phase timings and bundle sizes, which are key for optimizing performance and reducing build times.

This marks the beginning of exciting improvements to Meteor’s bundler, as we integrate modern solutions while maintaining Meteor’s performance and developer-friendly experience. Whether you’re working on a private project or contributing to the Meteor core, the new meteor profile tool is here to help you monitor and optimize the app’s build process.

Getting Started: A Quick Hands-On

Ready to dive in? To start using the new profiling tool, ensure your app is on Meteor 3.2 (or create a new one).

Update Your App

# Update your existing Meteor app to version 3.2
meteor update --release 3.2

Create a New App

# Create a new Meteor app using Meteor 3.2
meteor create meteorite-app --release 3.2

Profiling Your App’s Development Process

The key to Meteor 3.2's new profiling feature is the meteor profile command. Here’s how you can run it:

meteor profile [<meteor-run-options>...]

This command tracks the time taken across various phases of running your Meteor app, capturing insights that will help you fine-tune performance.

Here’s a Breakdown of the Profiling Phases:

Cold Start: This is the first run of your app, when no data is cached in the .meteor/local folder. (Use meteor reset to simulate this phase.)
Cache Start: The second run, where the app leverages cached data, improving startup speed.
Rebuild Client: When you change client-side code, this phase measures the time required to rebuild the client-side app.
Rebuild Server: Similar to the client rebuild, but this tracks the time to rebuild the server-side code.

With these key phases, you can easily track how your app’s performance changes as you make updates.

Here’s an example output from the small-sized Meteor React example, to see what it looks like in action:

A detailed log is generated during profiling, which you’ll find in the logs folder. This log contains full meteor run and METEOR_PROFILE output for each phase. Feel free to adjust the METEOR_PROFILE environment variable to suit your needs. For more options, run meteor profile --help.

Profiling Your App’s Size

The meteor profile command can also help you track bundle sizes. Run:

meteor profile --size-only [<meteor-run-options>...]

This command provides a breakdown of the package sizes across different bundlers, such as Meteor Modern, Legacy, and Cordova, helping you identify optimization opportunities. You’ll see the results in a neat table format, making it easy to spot potential issues.

If you want to include bundle size analysis as part of a full profiling session, simply add the --size option.

Tip: Exclude Architectures for a Faster Dev Experience

Here’s a quick tip to improve your development speed. If you’re not targeting legacy browsers or Cordova, you can exclude those architectures to speed up builds.

For example, compare the default behavior with excluding certain architectures:

# 1) `meteor run`
meteor profile

# 2) `meteor run` excluding certain archs
meteor profile --exclude-archs web.browser.legacy,web.cordova

The output comparison for the small-sized Meteor React example is shown below.

The impact will be much greater on large, full-featured apps. By excluding legacy and Cordova builds, you can see reduction in build times, especially when restarting Meteor apps ("Build App" stage in profile). These architectures are useful for testing older browsers or building for Cordova, but they’re often unnecessary during regular development, especially if you’re targeting modern browsers or platforms.

What’s Next for Meteor and Beyond?

Meteor 3.2 sets the stage for future improvements. The new meteor profile command helps ensure performance gains or size reductions without regressions. Automated profiling replaces subjective assessments with data-driven releases, now available to all Meteor developers.

Upcoming improvements to the Meteor bundler include:

SWC Support: We’re working on integrating SWC for enhanced compilation and analysis capabilities.
CPU Profiling and Memory Snapshots: This will allow for deeper performance tuning across all phases of app building.
Modern Bundler Integration: Expect improved bundler features and faster speeds with the adoption of modern bundlers.
Default Modern Architecture: Soon, Meteor will build only for modern architecture by default, skipping legacy and Cordova builds unless you specify otherwise.

These improvements will help keep Meteor aligned with current standards on the bundler side while improving performance and developer experience.

What Else Is New in Meteor 3.2?

Meteor 3.2 brings more than just new profiling tools. Want to explore further?

Join the Conversation

Watch the Discussion

Join the Meteor Renaissance!

Meteor 3.2 brings a new era of profiling tools, allowing developers to monitor app performance and bundle size like never before. With these updates, you’ll have the insights needed to optimize your app’s performance with data-driven decisions.

We’re excited about what’s to come and can’t wait for you to join the Meteor renaissance!

For feedback, questions, or support, visit our forums or join our Discord channel.

Stay tuned, and as always, happy coding! ☄️

Getting Started with Meteor 3: First Steps to Building Your React App

Nacho Codoñer — Tue, 06 Aug 2024 15:15:11 +0000

Meteor.js 3 is officially here!

Meteor simplifies the development of multiplatform applications by offering a stack focused on speeding up delivery. It integrates with the modern JavaScript ecosystem and provides a robust tool for implementing realtime capabilities in your app.

Recently, we built a real-time chat from scratch using Meteor.js to teach to newcomers how beneficial and simple it is to start a project with Meteor.

In this post, you'll learn how to set up your first project. We'll also provide over next weeks more content to help you understand this long-standing tool that has helped many developers and companies succeed.

Installation

Meteor works with Linux, Mac, and Windows.

To install Meteor, ensure you have at least Node 20 installed on your computer. Then run:

npx meteor

To verify the installation, use:

meteor --version

Choose your template

Meteor offers basic templates pre-configured to work with various libraries.

As a UI-agnostic tool, it allows you to select your preferred UI library and create your first app template with it. As the default example, React is used. To create a new app:

meteor create my-app --react

Explore more options with meteor create --help, such as --vue, --svelte, --apollo, --typescript, --blaze, --tailwind, --solid, and others.

Project structure

Any Meteor project can be configured as you prefer. By default, the skeleton you created follows this structure:

./client Contains HTML, CSS, and JS entry points for your client app.
./imports Contains shared modules, including client-side UI, server-side API endpoints, and shared code like collections.
./server Contains the JS entry point.
./tests Contains integration test definitions for your server app.

Remember, you can restructure as needed. You can also set the entry points for your client, server and test apps within your package.json file.

"meteor": {
    "mainModule": {
      "client": "client/main.jsx",
      "server": "server/main.js"
    },
    "testModule": "tests/main.js"
}

Run your app

To run your app:

cd my-app
meteor run

Congrats! Your app will be running at http://localhost:3000.

Explore more options with meteor run --help

Data management

To manage your application data, Meteor uses its own protocol called DDP, which also enables its standout real-time capabilities.

Query data

In Meteor, a publication is a server-side function that defines which data to send to the client, managing what data clients can access and subscribe to, and enabling real-time updates.

The skeleton example can be expanded by adding a new publication that filters the links data, displaying only those within the meteor.com domain.

// imports/api/linksPublish.js
import { Meteor } from 'meteor/meteor';
import { LinksCollection } from './links';

Meteor.publish('links.meteor', function() {
  return LinksCollection.find({ url: { $regex: /meteor.com/ } });
});

To import this publication to the app server:

// server/main.js
// ...
import '/imports/api/linksPublish';
// ...

To access the new subscription, update the code in ./imports/ui/Info.jsx to reflect your new publication.

//imports/ui/Info.jsx
// ...
const isLoading = useSubscribe('links.meteor');
// ...

Mutate data

In Meteor, a method is a function that you define to be called from both the client and server. It handles tasks like database updates and ensures consistent code execution across both environments. Additionally, it can be used to publish data.

To expand the app functionality and enable users to add and remove links, define methods.

// imports/api/linksMethods.js
import { Meteor } from 'meteor/meteor';
import { check } from 'meteor/check';
import { LinksCollection } from './links';

Meteor.methods({
  async 'links.insert'(url) {
    check(url, String);

    await LinksCollection.insertAsync({
        url,
        createdAt: new Date(),
    });
  },

  async 'links.remove'(linkId) {
    check(linkId, String);

    await LinksCollection.removeAsync(linkId);
  },
});

To enable these methods in the app, import them to the app server:

// server/main.js
// ...
import '/imports/api/linksMethods';
// ...

Import it into the client endpoint to enable Optimistic UI. This will display data directly in the client app without waiting for the server's response and will revert if needed.

// client/main.js
// ...
import '/imports/api/linksMethods';
// ...

To add this new functionality to your skeleton React app, modify imports/ui/Info.jsx to integrate the new management options into the Info component.

//imports/ui/Info.jsx

export const Info = () => {
    // ...
    const [url, setUrl] = useState('');
    const handleAddLink = (event) => {
        event.preventDefault();
        if (url) {
          Meteor.call('links.insert', url, (error) => {
            if (error) {
              alert(error.reason);
            } else {
              setUrl('');
            }
          });
        }
    };
    const handleRemoveLink = (linkId) => {
        Meteor.call('links.remove', linkId, (error) => {
          if (error) {
            alert(error.reason);
          }
        });
    };
    // ...
    return (
        <div>
          <h2>Learn Meteor!</h2>
          <form onSubmit={handleAddLink}>
          <input
            type="text"
            value={url}
            onChange={(e) => setUrl(e.target.value)}
            placeholder="Enter link URL"
          />
          <button type="submit">Add Link</button>
          </form>
          <ul>
          {links.map(link => (
            <li key={link._id}>
              <a href={link.url} target="_blank" rel="noopener noreferrer">
                {link.url}
              </a>
              <button onClick={() => handleRemoveLink(link._id)}>Remove</button>
            </li>
          ))}
          </ul>
        </div>
    );
}

Realtime experience

This example illustrates how Meteor excels with the DDP protocol and MongoDB. When a new domain with meteor.com is added, it automatically publishes only these links to you and all connected users of your app. This feature is particularly useful for apps that require real-time interactions.

The next picture shows that the newly configured publication will display only meteor.com domains.

Package management

Meteor lets you easily add your favorite packages to your project, providing flexibility to enhance your app with essential tools and libraries from both Meteor’s ecosystem and npm.

To add your favorite npm packages, install them using npm or, preferably, meteor npm to ensure compatibility with Meteor's expected version.

meteor npm install lodash

Meteor offers the extensive opportunities available within the Node ecosystem.

Deploy your app

Galaxy is the best place to host your Meteor apps. It offers scalable, secure, and managed hosting with built-in features like automatic updates, monitoring, and performance optimization. It includes a free tier for getting started.

To deploy your app for free.

meteor deploy myapp.meteorapp.com --free

Conclusion

Start with Meteor 3 is easy by following the steps provided. Experiment with the basics as well. Note that Meteor encompasses more than covered here. Content is being prepared to explore all possibilities Meteor 3 offers for your projects, specifically with the new renewed Meteor 3.0.

Among these possibilities are:

Easy import of packages, user role management, and social authentication login
Express for defining REST endpoints with HTTP
Native apps based on your existing web implementation
GraphQL for extended data management options
Atmosphere and third-party packages that add essential features to your app
and more

More resources

Join our community

Join our community to ask questions about Meteor 3, report issues, share suggestions, and contribute to this popular open-source project.