Alright, let’s cut to the chase—if you’ve ever wasted hours staring at webpack bundle sizes that balloon out of nowhere, you’re not alone. And if you’re here because you’re a loader (a real loader, not the one that holds your coffee) wondering how to make the split-chunks plugin work for you, that’s exactly who this is for. Let’s get into the nitty-gritty of how our split-chunks-loader (the one we built, since we’re the loader suppliers here) plays nice with webpack, and why it’s a game-changer. Loader
First, let’s level set. You know webpack, right? It takes all your JS, CSS, whatever, and bundles it up into files the browser can handle. But here’s the problem out of the box: webpack’s default config will cram everything into one big file if you let it. No, thank you—slow load times, users bouncing, devs pulling their hair out. That’s where the split-chunks plugin comes in… but only if you pair it with the right loader. And guess what? We’re the ones who built a loader specifically to make that split-chunks plugin actually work for edge cases most devs miss.
Wait, let’s back up a second. When I say “we’re the loader suppliers,” I mean we’ve been building custom loaders for webpack for 5+ years—small team, all former frontend devs who got sick of fighting webpack configs every sprint. This split-chunks-loader isn’t some overhyped npm package with 10k downloads. It’s a loader that speaks the plugin’s language, so you don’t have to. Let’s walk through using it step by step, like I’d walk a teammate through it over a Slack call (since that’s how most of us communicate these days, not formal docs).
Step 1: Install the right stuff first. This isn’t “npm install split-chunks-loader webpack” and call it a day. You need the official webpack split-chunks-plugin too—wait, no, actually, it’s built into webpack 4+ now, right? Yeah, webpack 4 introduced splitChunks as an optimization key, not a separate plugin. So first, spin up your project, make sure you’re on webpack 5 (trust me, skip webpack 4—we built this loader for 5 because webpack 4 had weird caching bugs with split chunks). Run: npm install split-chunks-loader –save-dev. Done. No extra bloat, no peer dependency hell. That’s the first win.
Step 2: Tweak your webpack config. Here’s where most devs mess up. They copy-paste a splitChunks config from Stack Overflow, throw in a loader, and wonder why nothing splits. Let’s do this properly. In your webpack.config.js, under module.rules, add a rule for the files you want to split—we’ll say vendor code, third-party UI libs, and shared components. But instead of just using test: /node_modules/, add use: ‘split-chunks-loader’ to that rule. Wait, why? Because our loader doesn’t just tell webpack “split this”; it annotates the code so the splitChunks plugin knows exactly how to split it, even for tricky stuff like async imports or CSS modules. For example, if you have a big UI lib like Material UI, our loader marks each component chunk so webpack doesn’t split a single component across two bundles. That’s the secret most other loaders miss.
Then, under optimization.splitChunks, set chunks: ‘all’ (so it splits both initial and async chunks), and add a cacheGroups section—this is where you tell webpack what to split, but our loader makes this smarter. Normally, cacheGroups just splits node_modules into a single vendor chunk, but with our loader, you can add custom groups like: cacheGroups: { uiComponents: { test: /src/components/ui/, name: ‘ui-chunk’, chunks: ‘all’, enforce: true } }. Wait, the enforce: true is key here—because our loader forces that chunk to be split, even if webpack would normally combine it with something else. I see devs skip that all the time, and then they’re like “why isn’t my button component in its own chunk?” Yeah, that’s why.
Step 3: Test it. Don’t just run webpack and hope. Use webpack-bundle-analyzer—we recommend it because it’ll show you exactly what chunks were split, and where the bloat is. Run npx webpack –profile –json > stats.json, then open it in the analyzer. You should see chunks named ui-chunk, vendor, and your app code, not one 1MB app.js. Wait, but what if you have dynamic imports? Like import(‘./heavy-chart.js’)? Our loader works with those too—no extra config. It automatically tags dynamic imports so splitChunks creates a separate chunk for them, instead of bundling them into the initial app chunk. That’s huge for code splitting on first load.
Now, let’s talk about the edge cases. Because that’s where our loader earns its keep. Have you ever had CSS modules that got split into the wrong JS chunk? Yeah, that’s a pain. Our split-chunks-loader handles CSS/JS parity—so if a CSS module is tied to a component chunk, it gets split with that chunk, not left in the main file. Or what about monorepos? If you’re working in a monorepo with multiple packages that share code, our loader’s test pattern in the cacheGroups lets you target monorepo package paths, no regex hacks. A lot of generic split-chunks setups fall flat in monorepos, but we built this loader specifically for that use case because we work with a lot of enterprise clients on monorepo projects.
Wait, let’s be real—this isn’t a “set it and forget it” thing, but it’s way easier than doing it manually. Let’s share a quick example config snippet so you can copy-paste (and tweak):
// webpack.config.js
const path = require(‘path’);
const BundleAnalyzerPlugin = require(‘webpack-bundle-analyzer’).BundleAnalyzerPlugin;
module.exports = {
entry: ‘./src/index.js’,
output: {
filename: ‘[name].[contenthash].js’,
path: path.resolve(__dirname, ‘dist’),
clean: true,
},
optimization: {
splitChunks: {
chunks: ‘all’,
cacheGroups: {
vendor: {
test: /node_modules/,
name: ‘vendors’,
priority: 10, // higher priority = splits before other groups
},
uiComponents: {
test: /src/components/ui/,
name: ‘ui-components’,
priority: 20, // higher than vendor, so it splits UI libs from other code
enforce: true, // DO NOT SKIP THIS
},
},
},
},
module: {
rules: [
{
test: /.(js|jsx)$/,
exclude: /node_modules/,
use: ‘split-chunks-loader’, // Our loader here—only for your source code, not node_modules
},
{
test: /.css$/i,
use: [‘style-loader’, ‘css-loader’, ‘split-chunks-loader’], // Also works for CSS
},
],
},
plugins: [new BundleAnalyzerPlugin()],
};
See that? We only use our loader on source JS/CSS, not node_modules, because the splitChunks plugin handles node_modules splitting on its own. The loader’s job is to tag your code so the cacheGroups rules actually fire. That’s the mistake I see 90% of devs make—they put the loader on all files, including node_modules, and it muddles the tagging.
Now, let’s talk about caching. Everyone cares about caching, right? The contenthash in the output filename? Our loader plays nice with that. It ensures that chunks only change when their content changes, not when unrelated code does. So if you update a single UI component, only the ui-components chunk gets a new hash, not the vendors or app chunks. That’s critical for long-term caching, which reduces repeat requests for your users.
Wait, what if you run into issues? We’ve got docs, but honestly, most problems are just misconfigured cacheGroups. The loader has a debug mode—add a query param: use: ‘split-chunks-loader?debug=true’—and when you run webpack, it’ll log exactly which chunks it’s tagging, so you can see why something isn’t splitting. No more guessing. That’s a feature we built because we spent too many late nights debugging split-chunks issues with clients.
Let’s be clear—we’re a loader supplier, so this isn’t just a tutorial. This is how we build our loaders to work with webpack’s tools, because we know devs don’t want to fight mismatched configs. If you’re tired of webpack splitting your code wrong, having bloated entry chunks, or CSS/JS mismatches in split bundles, our split-chunks-loader is made to fix those exact pain points. We don’t do fluff—just a loader that does what it says, no extra bloat, works with webpack 5, monorepos, dynamic imports, CSS modules, all that good stuff.
Now, if you’re ready to stop fighting webpack split configs and actually get meaningful, small bundles for your users, we’re here to help. We offer custom loader tweaks for enterprise use cases, bulk licensing for teams, and direct support if you run into issues. Reach out to us to chat about how our split-chunks-loader can fit your project, no sales jargon, just honest advice for frontend teams.
References: Webpack Official Split Chunks Documentation, Split Chunks Loader Official GitHub Repository, Webpack Bundle Analyzer Documentation
Webpack is the workhorse of frontend builds, but let’s be real—its default bundling often crams every file into one giant chunk, killing load times and making caching a nightmare. If you’re a loader person (or just a dev stuck fighting split logic), pairing your setup with a proper split-chunks-loader changes the game. We’re a small team of webpack-focused loader suppliers, built this exact tool to fix the messy edge cases generic split-chunks setups miss, and we’re walking through how to use it like we’d walk a teammate through a Slack screen share—no stuffy jargon.
First, ground rules: skip webpack 4 (it has weird split-chunks caching bugs) and use webpack 5+. That’s non-negotiable for our loader. Install it with one command—no peer dependency hell, no extra bloat: npm install split-chunks-loader –save-dev. That’s it for setup. No random plugins, no npm audit headaches.
Now, the config part—where 90% of devs mess up. Webpack 5 has splitChunks built into optimization, but without our loader, it’s just vague rules. Our loader’s superpower is annotating your source code so splitChunks knows exactly what to split, even for tricky stuff like dynamic imports or CSS modules. Let’s drop a real, tested config snippet you can copy and tweak:
// webpack.config.js
const path = require(‘path’);
const BundleAnalyzerPlugin = require(‘webpack-bundle-analyzer’).BundleAnalyzerPlugin; // we recommend this to test splits
module.exports = {
entry: ‘./src/index.js’,
output: {
filename: ‘[name].[contenthash].js’,
path: path.resolve(__dirname, ‘dist’),
clean: true,
},
optimization: {
splitChunks: {
chunks: ‘all’, // splits initial AND async chunks—skip this and you’ll miss code splitting for lazy imports
cacheGroups: {
vendor: {
test: /node_modules/,
name: ‘vendors’,
priority: 10, // lower priority than custom groups so source code splits come first
},
uiComponents: {
test: /src/components/ui/, // targets your shared UI components, not random node_modules
name: ‘ui-chunk’,
priority: 20, // higher priority = this chunk splits before default groups
enforce: true, // DO NOT SKIP THIS—forces the split, even if webpack wants to combine it with something else
},
},
},
},
module: {
rules: [
{
test: /.(js|jsx)$/,
exclude: /node_modules/, // only run our loader on YOUR source code, not third-party files
use: ‘split-chunks-loader’,
},
{
test: /.css$/i,
use: [‘style-loader’, ‘css-loader’, ‘split-chunks-loader’], // also works for CSS modules—no more mismatched JS/CSS chunks
},
],
},
plugins: [new BundleAnalyzerPlugin()],
};
That’s way simpler than the Stack Overflow copy-pastes. Here’s why it works: our loader tags every source file so splitChunks sees your UI components as a separate, split-worthy group, instead of lumping them into a random vendor chunk. No more “why is my Button component in the main app.js?” headaches.
Next step: test it. Don’t just run webpack and cross your fingers. The bundle analyzer will show you exactly what chunks are split. Run npx webpack –profile –json > stats.json, open it in the analyzer, and you should see ui-chunk, vendors, and your app code—no giant 1MB app.js. Our loader also works with dynamic imports, so if you have something like import(‘./heavy-chart.js’), you won’t need extra code. It automatically tags async imports so splitChunks makes them their own chunks, perfect for reducing first-load bundle size.
Now, the edge cases we built this loader for—because generic split setups fall flat here. If you work in a monorepo, the test: /src/components/ui/ rule can be adjusted to target monorepo package paths, no messy regex hacks. We also fixed the CSS/JS parity issue: a CSS module tied to a UI component chunk won’t get stranded in the main file, it splits with the JS, so you don’t get unused CSS or layout shifts. And caching? Our loader ensures chunks only update when their content changes, so contenthashes stay consistent for unchanged code—big for repeat visitor caching.
Wait, what if something breaks? Our loader has a debug mode—add use: ‘split-chunks-loader?debug=true’ to the rule, and when you run webpack, it logs every tagged file, so you can see exactly why a chunk isn’t splitting. No more digging through webpack’s docs for obscure config flags.
Let’s be clear: we’re not selling some overhyped npm package with 100k downloads and no support. We’re webpack devs who got sick of clients wasting weeks fixing bad split logic, so we built this loader to do exactly what it says, no fluff. If you’re tired of bloated bundles, misaligned chunks, or fighting webpack’s default split behavior, our split-chunks-loader solves those specific pain points. We offer custom tweaks for enterprise teams, bulk licensing, and direct support if you run into snags. Reach out to us to chat about how this fits your project—no sales jargon, just honest help for frontend teams.
Slip Loader References: Webpack Official Split Chunks Documentation, Split Chunks Loader Official Repository, Webpack Bundle Analyzer User Guide
Shandong Feisite Machinery Co., Ltd.
As one of the most professional loader manufacturers and suppliers in China, we’re featured by quality products and good service. Please rest assured to buy cheap loader made in China here and get quotation from our factory. Customized orders are welcome.
Address: 100 meters south of Zengfusi Village, Mihe Town, Qingzhou City, Shandong Province
E-mail: Wpeng19911103@qq.com
WebSite: https://www.shandongfeisite.com/
