# Element UI stays on Vue 2 while its npm package sits at 2.15.14 from 2023

> ElemeFE/element is the Vue 2 component library published to npm as element-ui at version 2.15.14, and it says plainly that Element will stay with Vue 2.x and sends Vue 3 users to Element Plus. The default branch is dev, the last push was 2024-08-20, and several of the project's own links still point at master.

**ElemeFE/element** — GitHub describes it as A Vue.js 2.0 UI Toolkit for Web. The repository metadata lists Vue as its primary language. The metadata lists the MIT license. This article stays within the project description and details documented in the GitHub repository README.

- Repository: https://github.com/ElemeFE/element
- Website: https://element.eleme.io/
- Stars: 54,043 · Forks: 14,389
- Language: Vue
- License: MIT
- Published: 2026-08-13 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/elemefe-element

## Element will stay with Vue 2.x, and Vue 3 users are handed to Element Plus

The most consequential line in this project is a commitment, not a feature. Element will stay with Vue 2.x, and the next sentence points Vue 3.0 users at Element Plus, described there as a community develop project, with a separate link for MiniProgram work going to MorJS. That single decision removes the usual upgrade question. A component library whose own maintainers have publicly declined to follow the framework's major version means there is no Element 3 release to wait for, no compatibility layer to configure, and no deprecation cycle to plan around. If your application is on Vue 3 today, nothing in this repository can be installed into it. If your application is on Vue 2 and will remain there, that same statement becomes an asset, because the API surface you are learning is not going to be pulled out from under you by a framework major version. The trade is stability bought with an eventual migration to another library, on a schedule the project does not set.

## The npm package ships lib, src, packages, types and web-types.json together

The published artifact is larger than a compiled bundle, and the files array is the reason why. It lists lib, src, packages, types, and web-types.json, with main set to lib/element-ui.common.js and typings set to types/index.d.ts. Two consequences follow. First, both the compiled output and the uncompiled component sources arrive in the tarball, so the raw source of every component is on disk in node_modules and can be read, wrapped, or monkey-patched without rebuilding anything. Second, the package carries editor and IDE metadata rather than only code, which is what lets tooling pick up component names and props from the type declarations and the web-types file. Neither of those is a defect, but it does mean the install footprint is not the same as the size of the single entry file, and the gzip badges tracked in the project cover lib/index.js and lib/theme-chalk/index.css, which are the compiled pieces rather than the whole published tree. Anyone auditing bundle weight should measure what their bundler actually pulls in.

## The default branch is dev while badges and contributing links still ask for master

The branch layout has drifted. The default branch is dev, and the newest release is v2.15.14 dated 2023-08-24, followed by v2.15.13 on 2023-02-13 and v2.15.12 on 2022-11-16. The last push to the repository is dated 2024-08-20, which is more than a year after the last tag, so work has continued on the branch without producing a release. That gap is exactly where readers get hurt. The coveralls badge queries branch=master, and every contributing guide link is written as a path under /blob/master/, including the four language versions in .github/. The changelog files that sit at the top level are named CHANGELOG.en-US.md, CHANGELOG.es.md, CHANGELOG.fr-FR.md, and CHANGELOG.zh-CN.md, while the detailed per-release changes are said to live in the GitHub release notes, which stop at 2023. If you are following the badges or clicking a contributing link from a clone of dev, you are reading master, not the code in front of you.

## Register everything with Vue.use or register components one name at a time

The quick start offers exactly two registration paths, and the difference is what ends up in your bundle. The full form installs the whole library at once, while the second form pulls in named components and registers each one through its own name property:

```javascript
import Vue from 'vue'
import Element from 'element-ui'

Vue.use(Element)

// or
import {
  Select,
  Button
  // ...
} from 'element-ui'

Vue.component(Select.name, Select)
Vue.component(Button.name, Button)
```

The first path is one line and gives you every component, including the ones your screens never render. The second is verbose and has to be extended by hand every time a screen needs a new component, but it is the only way to keep unused components out of a build. There is no third documented option here, no per-component auto-import and no resolver plugin, so a project that wants the second behaviour is writing a long explicit registration list. Whichever path you pick, the component names are the keys your own code will depend on, which matters more than the import style when you consider what a Vue 2 to Vue 3 move would cost.

## The file build fires four generators at once with an ampersand

Look at the build:file script and the ordering of operations becomes visible:

```shell
node build/bin/iconInit.js & node build/bin/build-entry.js & node build/bin/i18n.js & node build/bin/version.js
```

Those three ampersands are shell background separators, not sequential waits, so the icon initialiser, the entry builder, the internationalisation step, and the version step are launched as concurrent processes rather than a chain where a later step is guaranteed to see an earlier step's output. A failure in any one of them can therefore surface as a partially generated tree rather than as a stop. The theme build by contrast is a real chain, where a generated CSS file is followed by gulp against the theme-chalk gulpfile and then a copy of the compiled output into lib/theme-chalk. The deploy script mixes the two styles and finishes by appending a CNAME file rather than writing it, using echo element.eleme.io>>examples/element-ui/CNAME. Since the redirect is an append, the file is not cleared between builds, and anyone running deploys locally more than once should check what has accumulated in it.

## The Makefile documents itself in Chinese and one target points at a Taobao registry

Contributors get a Makefile, and the help target it prints is entirely in Chinese, listing targets such as make new <component-name> [中文名] for creating a new component package and make new-lang <lang> for adding a language to the site. The same file carries a China-specific install path alongside the normal one:

```shell
npm install --registry=http://registry.npm.taobao.org
```

That line is plain http against a mirror rather than the npm registry, so it is a choice a contributor outside that audience has to think about rather than a transparent default. Two more details matter to anyone building on this. make test runs npm run test:watch, a watcher rather than a single pass, so it is a development command and not what a continuous integration job should call. And the top-level tree carries a temp_web/ directory that the project files never mention, alongside the yarn.lock, .travis.yml, Makefile, and components.json that drive the build. Scaffolding new components and new languages is otherwise scriptable through build/bin/new.js and build/bin/new-lang.js, with the argument forwarding written as node build/bin/new.js $(filter-out $@,$(MAKECMDGOALS)).

## Theming needs the source tree and gulp, not just the published CSS

The theme is a build product with its own pipeline, and the published package is not enough to change it. build:theme generates a CSS file, runs gulp against packages/theme-chalk/gulpfile.js, and copies the result into lib/theme-chalk. The customization path offered to users is the theme documentation page, backed by a separate browser-based generator hosted at elementui.github.io/theme-chalk-preview for previewing and generating a theme online. Everything in that chain points at the theme-chalk sources and the build scripts rather than at a runtime variable you can set on a container. A team that has installed element-ui from npm and wants to restyle it therefore needs a clone of this repository and its build tooling, not a stylesheet override, and the repository describes no runtime theming hook that would let you adjust the palette after install. Theme work is a fork-and-build activity here, and it should be scoped as one.

## Conclusion

Element UI is a sound pick for a Vue 2 codebase that is also staying on Vue 2, since the package, type declarations, theme-chalk CSS, and documentation in four languages are all in place behind a single install command. It is the wrong choice for anything starting on Vue 3, and this project offers no migration path of its own. Before adopting it in new work, confirm your Vue version is still 2.x, check which release you are actually pinning given that v2.15.14 is dated 2023-08-24 and the last push to dev is 2024-08-20, and decide in advance who will carry browser and security fixes for a component library that has not published a new version since 2023.

## FAQ

### what is element

In this repository, element is ElemeFE/element, the Vue.js 2.0 UI Toolkit for Web published to npm as element-ui at version 2.15.14, with main entry lib/element-ui.common.js and typings types/index.d.ts. Its description in package.json is A Component Library for Vue.js.

### What is a simple definition of element?

For this project, element means the component library rather than a scientific term. It is a Vue.js 2.0 UI Toolkit for Web under the MIT license, documented in English, Chinese, Spanish, and French, and it states that Element will stay with Vue 2.x.

### what is element in science

Nothing in this repository addresses chemistry. Here element is ElemeFE/element, a Vue.js 2.0 UI Toolkit for Web whose homepage is element.eleme.io and whose npm package is element-ui, with separate sibling repositories for React and Angular.

### how to install element 3d in after effects

That question is about a different product, since this repository is a Vue.js 2.0 UI Toolkit for Web rather than a video plugin. Here the install is one shell command, npm install element-ui -S, and after that you either register everything with Vue.use(Element) or import individual components such as Select and Button and register each with Vue.component using its name property. The package is element-ui at version 2.15.14, released 2023-08-24, and it requires Vue 2.x.

### What is called the element?

The project answers that name for itself: element is ElemeFE/element, MIT licensed, with the npm package named element-ui and the homepage at element.eleme.io. It carries Editor helpers for Atom and Visual Studio Code, separate ports called Element for React and Element for Angular, and starter kits named element-starter and element-in-laravel-starter.

## Sources

- [Official documentation](https://element.eleme.io/)
- [Official README](https://github.com/ElemeFE/element#readme)
- [Project repository](https://github.com/ElemeFE/element)
- [Release notes](https://github.com/ElemeFE/element/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/elemefe-element