Do you use an Email client in Emacs?
No Mu4e notmuch Gnus Rmail Wanderlust mew MH-E VM Mew vm mh-e I have used Wanderlust, but gave up. I wish I could, O365 integration stops me Tried Gnus, notmuch and Wanderlust. Eventually I decided that email is not a thing Emacs should handle.. I have Mu4e working, attempting to transition to gnus tried, but don't like the approach gnus AND notmuch No, but my MUA calls emacsclient and runs post.el; and I do M-x debian-bug which sends an e-mail from Emacs in the end I used notmuch in the past, but it's too much bother to maintain a proper, working email configuration for too little gain firefox from within exwm HTML to Outlook couldn't get it to work with Apple's IMAP... yet. Used to in the past when Thunderbird had an external editor addon Used to use vm, loved it Not yet (but I want to) mu4e, but its configuration is awful and it is one of the most troublesome packages in my emacs configurations mu4e, notmuch I used to use gnus. Outlook calendar integration with webex messenger made me sadly move M-x mail I used to but not anymore gnus in the past wanted to use mu4e, failed I use vim Gnus previously, now outlook (company requirement) Way, way back, I did all of my email, but the current rmail doesn't understand my simple (at least from my viewpoint) set up. that is on my TODO list Tried but never got it to work I used to use vm mail, but I can't any more. used mu4e in the past under 35 gnus and notmuch I don't know... Multiple I've used Gnus in the past but don't any more Tried but got frustrated and went back to thunderbird not yet I'd like to but haven't tried yet not at the moment. but will in the future. Not decided client yet I'm interested in using it, but never tried it No, but I want to get to it Occasionally because of work environment My own not yet published Gnus on my windows work computer, Mu4e on my personal mutt inside ansi-term no, former gnus Used to, but not possible due to recent 2fa compose emails in emacs and send them as mailto links to other program emacs-maildir nmh I /kind of/ use both Gnus and Wanderlust but both have problems and I find myself discouraged from using them exclusively, all the time Mutt in vterm no, haven't found one which is sensible (sorry, Gnus), easy to use/configure and supports IMAP imap I used to, but it was too much of a headache I already use a text email client which I am already hooked to, nmail, but emails in emacs look appealing too. Only as editor for mutt Have not yet explored, due to lack of time No but used to be a heavy mu4e user Used to use mu4e have used Gnus but moved to mu Haven't decidedf planning on using notmuch or mu4e generally no but everyone few years I start trying to write a mode to make gnus work more like pine/alpine then give up. Only in Linux himalaya I used to all the time, but employer email requirements made it hard/impossible Claws - use emacs as external editor Tried it No but I'd like to Not yet but I plan to mutt I want to! What do you think are Emacs' greatest strengths?
Extensibility extensibility Elisp org-mode elisp Extensibility. Org mode Flexibility Lisp Community Customizability Customization Extensibility, community Org-mode configurability Programmability Packages flexibility Emacs Lisp org mode Extensibility and community customizability It's extensibility lisp Orgmode Magit Org Mode Extensibility, packages Its extensibility magit Customisation Extensible Customisability Its extensibility. orgmode Adaptability extensible Versatility Longevity extensibility, community The extensibility. packages The extensibility Elisp, community extensibility, elisp community Extensibility, Elisp Documentation Malleability Extensibility and configurability Customization. Extensibility and the community extensibility, customizability Extensibility, Customization Hackability Extensibility with Elisp Extensibility and freedom extensibility and stability Configurability Extensibility, introspection, documentation longevity free Customizability and extensibility. Self-documentation and extensibility. Package ecosystem Extensibility and customization How customizable it is Introspection and extensibility programmability Extensibility and ecosystem versatility all in one Consistency Flexibility/extensibility extensibility, configurability packages and extensibility Stability configurability, org-mode Extensibility, documentation Stability and extensibility. Emacs lisp Extensibility, elisp Extensibility and discoverability Extensibility and maturity. Macros ORG mode Programability Extensibility and elisp hackability Community and extensibility packages, extensibility Extensibility! Extensibility and the package ecosystem expandability Extensibility and community support macros Easy extensibility Its extensibility and its ability to become the one editor for your every need.
Also its proven ability to change with the times so it can truly be your editor for life instead of just another flavour of the year like many other editors tend to become. LISP Extensibility, customization Integration Customizability. Open source Customizable Text editing features. Configurability and extensibility extensibilty Extendability emacs lisp Package ecosystem, extensibility Extensibility and the community. extension stability extensibility and community Configuration Extensibility and customizability Cross platform Extensibility, customizability elisp,extensibility Extensibility and documentation It's extensibility. customization extensibility through elisp Freedom Extensibility, org-mode configuration/extension, packages, doesn't force me to work any particular way, runs everywhere I need it. Elisp. Elisp means Emacs development can move faster than any other editor, and the Emacs community can produce disproportionately good plugins for its size. Very easy to customize to fit my workflow. n/a Free software, stability, documentation, customizability. Extensibility, interactive configurability, self-documenting, the philosophy that everything should be in an integrated environment. Its extensibility is impressive. I use it along with org-mode to keep track of TODO's and to produce my reports. The help system - being able to pull up the documentation and possibly even the definition of a function or variable is incredibly useful when understanding what's going on.
Being able to write ad-hoc elisp commands is a great way to augment the current editing session too. org-mode. extensibility; flexibility; availability of extensions for much more than my basic needs highly configurable being extensible and community driven Very quick even if the editing file is huge. Extensibility, big number of packages, consistent UI, serves as a poor man's tiling window manager Customizable, extensible, dynamic (no compilation to modify emacs), extensive programming language support the efficiency you can get when customizing it for the tasks your doing. org-mode and helm in particular are hard to live without. It handles having many files open simultaneously well Extensibility & the community willing to improve things around it. Buffers and text editing Its ease of use and it's ubiquity in *nix environments. It provides an easily extensible computing environment with a common interface able to attach and act upon metadata relevant to projects it is being used for and to control the rest of the system.
This has allowed for its use in creating an audio desktop environment like Emacspeak.
It's a Lisp environment. Text editing features (sorting, macros etc). Extensibility and library of elisp functions (if I need something someone has probably already done it). The infinite posibilities Consistency and extensibility Completion makes it very easy to discover the tools offered by built-in and package-provided functions. You can change pretty much change everything if you want faster and more customizable than others FOSS, flexibility In my opinion Emacs greatest strength are its extensibility and discoverability. Yes, it might not look very discoverable at first glance, but as soon as you get it. Everything can be explored, understood and modified. Emacs provides a single powerful, text editor for all purposes on all platforms Extensibility, performance, flexibility being programmable.
org-mode. Faster text editing than vim since it is not modal (vanilla keybindings), extensibility, an integrated environment to do most text-based things inside, Org Mode for markup, literal programming (useful in my studies) and organization excellent packages, everything is text Extensibility, Org Mode (specifically in-buffer LaTeX support) The power of using the same functionality for a lot of different tasks: Editing text, commit messages, web browsing, etc. Extensibility, customization, people making packages Being so far off from the sad state of things which is nowadays' (ekhem, "modern") sotware. Extensibility and strong community. Text oriented and extendability Simplicity, speed, community Emacs' greatest strengths are its extensibility and its ability to be completely customized to your needs. However you are most productive, you can make that workflow happen within Emacs, and optimize it as far as you wish. The drawback being that it may take extensive time writing the configuration. Extensibility, customization, 3rd party packages... Customizability. Great language support. Longevity ... the product will be around in 20 years. It's ability to adapt and grow over time, such as incorporation of LSP support. Free software! I can't support a proprietary product for something so central to my job, software development. It's easy to use display, multiple buffers and flexible multitasking org-mode, extensible, packages, key binding, self document The hotkeys and number of packages, especially org-mode Its IDE capabilities. Extensibility within common muscle memory techniques. I don't have to throw away old habits to build new ones. Extensibility and personalization That it can be anything you want it to be. It’s extensibility and longevity Flexible customization allowing an individual to mold Emacs to best fit their particular use cases as well as the ability to maintain a cohesive UI across many different working contexts (task management, coding, email) in a tightly integrated fashion. Org-Mode - elisp
- built-in documentation it's a Lisp system Flexibility, extensibility Extensibility, huge package ecosystem, and Magit. Very flexible Platform TRAMP Written in lisp. Native gui on all major platforms. Good balance of stability and improvements over time. Pure free software, independent of the whims of a corporation. Extensibility (both the language used and the mindset) and self-documentation Extensibility + great number of packages. Flexibility/customizability It's fast, and so easy to configure. I left vim because I wanted to do more and more in it, but the manual is hard to understand and navigate, and the configuration language is the same. Extensibility and understandably Documentation, changing values on the fly extensiblity if you are comfortable with LISP Extensibility, principles The fact that everything appears as a buffer of text and can therefore be manipulated as such. Fully keyboard driven, extensibility, and prose The extreme extensibility Non-dependence of mouse Extensibility and its solid concepts of windows, buffers, frames, modes, etc. It could be configured for anything and does not require a lot of resources The vibrant community around it.
I think what really put me off about VS Code was an apparent disconnect between the Marketplace and where Packages are developed.
IMHO it is far 'easier' to write an issue on any git host and get support than it is for the Marketplace... libre software, text manipulation is possible everywhere, magit, org-mode consult/embark is the only thing keeping me from using vscode Age, malleability, adaptibility elisp and a strong package ecosystem Stability over time org-mode & package extensibility malleability. that's literally it, every other editor is better except at being emacs Programmable run-time. Cross-platform. Open source. Malleability: hooks, macros, minor modes... It's extensive history and ability to find answers in many places/communities online. The ability to configure the client itself Flexibility, hackibility, configurability Extensibility, uniform interface, easy interaction with external commands It's easy to customize and extend. lisp dynamic extensibility and the big ecosystem Emacs is highly extensible, which helps it achieve a very high amount of packages which extend the core functionality of emacs. Universal vim keybindings for coding, mu4e and org-mode through evil-collection A lightweight, "hands-on-keyboard" experience. Extensibility by the community and by the user themselves. The enormous library of packages and the continuous work done to improve it. Extensibility, self documenting Extendable and community Complementary function Portability, flexibility due to configurations Being defacto lisp editor Extreme customization and extensibility from elisp Extensibiliy, orthogonality of features, proper language for extensions. Org mode
Extensibility Simple powerful features easily configured to fit how I think. Org-Mode
Config as I want Emacs provides a consistent and powerful tool that covers the majority of my daily workload, i.e.:
Drafting messages, emails etc...
Running quick calculations / templating more complex formulae
Maintaining to-dos and deadlines.
Drafting articles and formal and informal notes / minutes.
Having a little bit of quiet fun, e.g. with lunar phases, nyan-mode, quiz etc... The idea of modes. The configurability of the packages, and the fact that the package system now seem stable and reliable. Also, the fact that so many language packages now support LSP makes Emacs the best system for hacking code. Extensibility via elisp Customizability, lispiness Good packages. Support for many languages Flexibility. Emacs treats me as a person, not as a laborer. It gives me the option to extend and change things to suit me best. Extensibility and configuration. I think Emacs' greatest strengths are its extensibility, and its ecosystem of 3rd party packages Lack of stateful key binds (vast majority are non-modal unlike vims) Incredible flexibility and extensibility through emacs lisp programming, especially with some common-lisp extensions. Ability to customize key bindings to perfection. A wide variety of packages to provide useful functionality. Pre-bundled collections of configuration (Doom, Spacemacs, etc.) for new users who don't want to start from scratch. Extensibility and text editing. I don't think it's great as a programming editor bc there isn't as much of a separation of concerns, but that's just me. Extensibility as well as the implementation and support for add-ons for org-mode. Its integrated primitives and extensibility. I love that I almost never have to leave it for most common computing tasks I have and how easy it is to extend and script: windows, pop ups, form input, interactivity, networking, file system access, etc. I wish I could have a computer that booted into eMacs. Extensibility. Self-documentation. Providing an "all-in-one" user experience Org mode, the extensibility. As a LaTeX editor it's much more efficient than anything else I've used Extensibility and package ecosystem org-mode, customizability/extensibility/configurability/integrability, free (libre) software, the community, its design, I can do everything without leaving Emacs Being a GNU. Endless extensibility. Community. I can program everything that I want and has org mode and magit. Doesn't need an internet connection; can chanfe the behaviour and appearance of (almost) everything; when input is requested it is not modal and I can change buffer even when the minibuffer is asking for something. Lisp for configuration is just the best Org-mode, extensibility, ability to do everything in one window, possibility to create own software withing Emacs to automise tasks It's flexible and works on most machines Expandability - Customizability.
- The sheer number of modes you can switch between. I can write code AND write prose in the same editor, have those modes look completely different, and output pdf/latex/html through a couple commands. Extensibility and customizability. The community and the fact that Emacs is fully extensible and self-documenting. It never ceases to amaze me how I can easily read and learn from the code behind packages and commands. having a lisp function behind every keystroke, full screen real-estate, no mouse required It has almost all the tools I use on a daily basis within Emacs, such as IDE, notepad, client API and more. custom define Elisp provides an incredible control over how we can extend emacs. Hackable, community It's the user interface of the GNU system It's very customizable. Also it supports so many programming languages and other formats. Extensibility, configuration and documentation. Extensability. Integration of all tools into the emacs way. The speed of editing it enables, ease of use (after learning the keys), daemon-client, org-mode, exporting options from org-mode, community, packages for everything. familiarity extensibility in a full fledged language package ecosystem, rich runtime Buffer protocol, lisp integration incremental search Customizability around editing activity Extensibility; relatively easy language to write your own package or modify existing ones free as in free speech
free as in freedom Lisp environment Flexibility, extensibility, independence. Everything is a buffer, so most of my key-binds for navigation and selection still hold, and I get to keep my kill-ring with me the whole time. Powerful editing, nice packages. you can find a package or tweak for everything Good, generic concepts Flexibility, code (core and packaged) solving lots of problems, being a central text interaction environment, community elisp and the ability to program the editor, including writing code and macro recording. That you can completely customize your editor. It is a lisp machine. Greatest strengths of Emacs is how easy it is to extend and having huge repository of existing packages. Rich extension environment, extremely configurable, powerful, flexible. Community configurations provide intuitive keybindings making it easy to navigate and use. No mouse usage, tramp Lots of build in features.
Ready to use out of the box EVERYTHING * Flexibility
* Dynamic. Self-discoverable The flexibility to mold it to be whatever I want, along with a ton of amazing community packages like magit and others. Extensibility, governance model, slow response to gimmicks in the marketplace Continuity The GUI is largely superior to what (Neo)Vim offers, which is perfect for prose and math. Extensibility, common editor for all editing needs, org-mode Ecosystem of great packages. org-mode is incredible automation of the writing with enough experience UI, Keyboard centric and extensibility Its extensibility and community. Plus, it's been around since forever and therefore people have had a ton of experience with it. Elisp, VC Extensibility, with a wonderful language like LISP A pleasant and helpful interface that's organic, intuitive, and highly actionable. packages and community extensiblity - extensibility
- great community
- relatively fast
- org-mode tweakability Depth of editing power, super, extensibility. amazing community and packages extensibility, customization There is a mode for almost any language Customizability, packages Its long history Extensibility, personalization flexibility, customization and performance Extensibility and org mode Keybindings Works consistently on multiple platforms, a billion packages for just about anything, easy to customise to work how you want. The fact that I can do everything in Emacs. I also like how it’s evolving with LSP and tree sitter. Gets out of the way when desired to just sit, but powerful with easy and flexible configuration and extension Extensibility, completeness Self documentability
Uniformity of the environment It is free and open source, it is supported by the GNU project and it is highly customizable. Emacs keybindings are familiar (BASH, Readline, etc.); regular expression support (albeit the default requires more escaping); Emacs is highly extensible; I use Emacs for editing large files of plaintext, markup language, and code because Emacs feels better for long-form typing than vim. I moved from vim to Emacs because of org-mode, which is *excellent* for structuring plaintext. I also find myself launching Emacs just to use the calculator, because anything other than RPN frustrates me. edit text Its rich ecosystem which supports practically any relevant (or even irrelevant) use case. Community, configurability, extensable, adapt to user You can use the same set of custom (vi) keybindings to navigate and edit all kinds of text buffers. High grade of uniformity.
The set of core primitives is *fairly* small. Compare that to e.g. Vim that has had a lot of trouble with adding buffer change callbacks since every place in the code base that edited text had to be made to call callbacks. Extensibility, org mode, flexibility documentation packages Extensability Written in Lisp Extensibility, keyboard focused editing (no need to use a mouse), magit, org-mode Extensibility and documentation. Being FOSS is a major strong point. Extensibility, and Freedom. It’s a lisp machine with some great text editing built on top. I could tweak it to suit me perfectly. Also I am huge fan of defining everything in code, and emacs, especially doom let's me do just that perfectly. Wide ecosystem of packages; numerous use-cases for technical and non-technical purposes. Configurability and customization Consistency, extensibility I can easily write Emacs Lisp and extended it to do what I want Keyboard shortcuts, extensibility One editor for all text tasks on all platforms Lots of community packages Extensive documentation and helpful community. Org-mode is big draw for me. Ability to work with workspaces, buffers, frames, and windows is great. It is versatile in its extensibility. Using Emacs may be (initially) more difficult than other text editors for some tasks, but I find you usually 'can' do it in Emacs with enough effort. There is the additional benefit of using Emacs in that I feel I am learning and growing skills the longer I use Emacs. Extreme customizability. The best motto I've seen for Emacs is, "the editor of a lifetime." I'm able to mold Emacs to fit me perfectly, which both makes it easier for me to do things with Emacs, and is fun in its own right. In a sense, this is a form of lock-in, since I can't imagine spending the time to make another editor work just right. However, the fact that Emacs' development (and the FSF's philosophies in general) are much more aligned with my interests as a user, this isn't really a problem in practice (most people wouldn't feel too worried about being "locked into" their dream home). This is in stark contrast to being locked into something like VS Code (which, to extend the housing analogy, is probably more like renting an apartment). Extensibility/moldability Having the same keybindings when writing code and plain text - extensibility
- self-documentation and discovery user friendliness, 'no surprises', extensibiity, dired, onboard help, packages like helm, ztree, magit Flexibility and customization The ease of extending its functionality. It is built to be modified. Atom had that same goal in mind, but Emacs is the only editor that's ever truly achieved it. the whole elisp and its ecosystem Visibility/Editability/Extensibility Extensibility and the REPL Extensibility, ability to act as a universal interface for editing text Extensibility and customizability. And Org-Mode. Tinkerabilty The ability to mold it and customise it to the way I want to work. I think emacs has very good key bindings. It is also cross-platform and runs comfortably. It is also open source, and I am learning programming myself while looking at the Emacs's source code. Package ecosystem, TUI, elisp document navigation: once you learn a few keybindings, you can fly around your document with ease.
the joke "it's a great operating system that only lacks a decent text editor" is pretty accurate. i mean, i love it as a text editor, but being able to drop into a shell or load a package to interact with a matrix server or irc server without leaving emacs... to be able to put any-data-at-all into my kill ring (and interact with it(especially using rectangles)) is awesome. Its extensibility. I'm able to do most of my computing within emacs. Its customisability and community. Consistent development environment across multiple languages; uniquely powerful packages (org-mode); customisation/extensibility; free software ethos. extensibility and good support for various programming languages Being a virtual Lisp machine. That if something doesn't work, I can program it to work. Also the times I've used the scratch buffer as a glorified calculator (with comments!)... It's intuitive, at least for me. It's also platform-agnostic which makes it easy for me to migrate my configuration from one system to another. Extensibility, slow rate of change Open,Free,Extendible,Immersive stability, maintenance, packages The possibility to customize the behavior exactly as you want it. If you need additional features, you can easily write your own function and add it yourself. You are not stuck with the features somebody else thought was good for you. the sheer flexibility of exposing the things its build with. other editors can only be extended through set APIs while in emacs crazy things like org-mode or eww can exist. emacs is the ultimate in malleability. It's free(both monetary and metaphorically) and not subject to change or become paid at the whims of a company. I can change almost all of it if i don't like anything. Hackable + customizable Extensibility for complex tasks, simplicity for the ordinary ones. It's history, extensibility, a lot of community packages, and the most powerful markup language: org. Customizability and packages expected consistent behaviour Versatility. I can use it to work with a lot of different languages. It is not the best tool for a lot of things (like big Java maven projects) but the fact that it can do almost everything well enough allows me to use a familiar environment to work with.
Extensibility. Having so much be configurable, and all the great packages available from the community allows me to have a workflow that works really well for me, with a constant cycle of learning new ways to make my life easier. Extensibility, major modes, easy to read/understand packages. Ability to fully customize almost everything. extension and packages Ability to provide text manipulation functions which are unique to Emacs and org mode. The programmability. I wrote my own little packages and some small functions to get daily work done. With a full programming language (elisp) it's possible to do everything in Emacs. Extensibility, self-documenting Composability of the many functions Customizablity Extensibilty, customizabilty extensibility and adaptability Extensability, magit, key mapping Extensibility, flexibility, customizability. Customizability and Control over the IDE Fast, clean Ability to write settings in lisp. The ability to alter the behavior of the editor on the fly while I'm doing my work. Keybindings are separate from input the input method, i.e. I could be writing in Korean or English, the keybindings are the same (unlike some editor called Vim). Feels like I can edit any corner of any option and customize to my content It will always be there Not running in terminal (compared to vim). Otherwise, ecosystem and that it's free software elisp ecosystem Everything is text and buffers not backed by files.
Makes it possible to do anything that involves text. Elisp, Packages Extensibility, freedom, stability, community. runtime, shell, *nix tools integrated with editor Programmability, unix integration Org-mode!!! Works in a terminal Complete and light You can run JOE instead of Emacs Keyboard shortcuts are similar to bash/zsh.
No dual mode like VIM Almost always available on remote machines. The extensibility and windowing/buffering system. Its a lisp machine! Speed, orgmode, personnalisations. Spacemacs like keybindings Community and amazing packages I like that editing shortcuts are mostly the same as in readline/bash.
Selection of packages. Keyboard macros Extremely customisable Freedom, Documentation, Community, Elisp. flexibility, stability, extensibility Hackable Lisp-programmability, documentation, Org, users and developers I can type things Introspection (great way to discover new commands) and many many packages LISP environment. Live, moldable environment.
Cohesive but extensible system.
(Great example is the recent vertico+orderless+embark+etc system which has fully replaced helm for me) Lisp, self documenting, extensibility, EXWM is one of the main reasons I use emacs. The best window manager I've used so far, the greatest thing about emacs is emacs-lisp and org mode. extensibility, org-mode, magit, macros Good default keybindings, extensive utility through open source packages, easily tweaked to your liking Not bound to the plans of a single company, like VS Code. Stock parts of the editor can be changed (e.g. I tweaked tramp). Defining my own keybindings, extensibility and modes like magit. years of community development, many extensions for almost any occasion Its stability, and the wide variety of rock-solid packages that are available. A lot of the packages I'm using are almost as old or as old as I am (22), and it's good to be in an ecosystem where I know the support rug won't be pulled out from under me. org mode for daily journal Extensibility in Elisp, great primitives for manipulating text and interacting with the operating system, and a community of hackers who recognize the value of those Hackability. I think the ability to use Emacs to troubleshoot, edit and test Emacs functionality all from within the same environment. It gives the user incredible power and the feeling that that tool is really in their control. Extensibility, fully open The extensibility. Emacs gives me control over how I want to do my computing and for how I want to orient my life overall. For example, YouTube has incredible videos on their platform. Professors uploading complete lectures and individual creators uploading tutorials about the nuanced ideas in programming I never considered. But YouTube is incentivized to keep you on their platform. Their recomendation system is amazing. Using Elfeed and MPV I can completely curate my feed exactly how I want and only spend as much time I deem worthy on YouTube without being drawn in subconsciously. The elisp core so it's customizable to any liking The extensibility and community. Extensibility, packages, the sense of packability it gives you. There's a moment where you first realize that you can change literally anything that is hugely empowering. 1. rectangular editing commands
2. org mode
3. Code indenting
4. code highlighting
5. Macros Run-time introspection and modification Keybindings and customizability keybindings Can run without any graphical interface. hackability, documentation, and long life which allows me to customize it as i see fit, without worrying it will disappear Extensibility and being a blank slate Extensibility and user control At its core, its extensibility and how customizable it is. It allows you to an environment specially crafted for your needs. The fact it's not just an IDE, but a file browser, a note taking tool, it can replace the entire desktop if configured that way. Extensibility and ability to do everything inside Emacs without moving to another program and losing your flow. Also, Magit is amazing. The fact that it interprets its own language, making it probably the most customizable piece of software I have and will ever see. Also, it's Free software, adding to its strengths. Extensibility
Everything actions is an elisp function
Magit Extensibility and powerful common packages like Magit, Org, etc. It's an integrated interactive development environment Tooling for various use cases modes That is a living, breathing, fluid, programmable dynamic environment, that is interopable, discoverable, reactive, can be deeply at will introspected (as in its own state, self-documentation etc), easily hacked, modified, integrated (both, internally within and outside the environment), composed and limitlessly extended. dynamc, extensibile, self-describing, open-source software The community molds Emacs to current trends and keeps it relevant. One of the few, powerful editors that also can run in a terminal. Extensibility and the community, Extensibility, org-mode, steadily improving IDE capabilities Extensibility, very broad range of build in and external packages Shortcuts and commands free, customizable, elisp Extensibility, transparency. If I want an editor with some feature I can make emacs be that editor. Consistency accross packages, extensibility, magit and org mode extensibility
availability It's immense resourcefullness, in being able to tackle any problem, pertaining with text. windowing Extensibility, diverse code base It's configurability Extensibility, it's free software, it's been around for many decades so it'll likely still be here in a couple more decades. Extreme customization, modules, and fantastic packages. I think Emacs shares many of the strengths of Vim/NeoVim. You can do anything you can dream of with Emacs and customize it to fit your exact wants and needs and tailor the experience to fit you. Its a very powerful text editor where you can quickly navigate to anything with your keyboard. Additionally its FOSS and supports many IDE like features which allows developers to write code without the need of a company driven IDE. I think the biggest strength of Emacs compared to Vim/NeoVim would be that it runs in a GUI environment. It can do quite a bit more with a GUI environment such as different sized fonts, images, smooth scrolling, and so much more. Longevity.
Extensibility Extensibility: being able to fully understand emacs and, upon that, build the perfect editor cross platform, always available, packages for everything Emacs has better key bindings than any editor, except maybe Vim. It's easier to use multiple panels with Emacs than Vim. Emacs has excellent built in support for programming alongside an interpreter. Emacs is free software! It's extensibility and it's community Extensibility. Emacs is a toolkit which I can shape to be exactly what I want. Ease of extensibility, great community and how reliable it is fast and robust, org-mode Flexibility
Broad user community means there is special-case support for almost any odd special case I am a part of Flexibility, open source Complete control over the internals and UI. It is a generalised execution environment. Extensibilty, interface orthogonality. customization and community support Extensibilty Extensibility, multiplatform support, Lisp-y architecture, free software, keyboard-orienting controls. Extensibility, writing, Org mode, IDE feel, image viewing (GUI) consistency, extensibility There's probably a package to do more or less anything I'd want to do. If not, it's easy enough to duct tape something together. Being a lisp runtime/repl Dedication by the people who do maintenance, offer help, respond on the mailing list, contribute source code to upstream, and/or contribute to packages... just wonderful people. Many, many thanks! Some packages like org-mode, magit. I love org-mode. If only I could convince more people to switch from markdown – the lowest common denominator – to this very capable format.
Kind of integrations like tramp, for going on a server via SSH and into a docker container running on the server. Also how well things work together. For example starting a `M-x shell` when doing something on a server via tramp, will start the shell on that server using an executable on that server. Same for dired working flawlessly together with tramp. Things work together like that, while in other editors each plugin is an island.
The unparalleled ease of editing code of lispy languages. There is some kind of in-built understanding of the structure of code.
I like buffer management. I often have up to 50 buffers opened. If I imagine having those all as tabs, I would not find anything. But in Emacs I can quickly switch between buffers. I don't need to have the file tree opened to find that buffer again or things like that.
I think the plain text interface orientation and keyboard centric mindset are the greatest strength. Any buffer can be searched, the cursor can jump to search results and one can take action there. For example other editors might also have integrated terminals, but what if I want to quickly navigate to some part of the terminal output and copy stuff from there? Not possible without reaching for the mouse. If there is a lot of output, then even searching that output might be annoyingly cumbersome. It is often mentally taxing to watch others fumble around in their VSCode editors and closing and opening up new editor instances again and again. I want to do my thing, ideally at the speed of thought, and Emacs gets me closest to that. Elisp and keybinding flexibility His extensibility and org-mode. Extensibility and observability and freedom - to make it mine. Almost anything can be customized to fit my personal needs. Keyboard oriented. Extensibility/Community Extensibility, customizability and community lisp machine, minor modes, org-mode Extensibility and introspection. Extensibility, along with a great community willing to make use of it and share the results. Simplicity, performance, extensivity, tweakability, interface simplicity (no distraction) Not being Joe Everything can be customized and there seems to be pretty good autocomplete support lately. There is a way to do everything inside emacs. You don't have to leave the editor for other tools. And magit is one of the best git clients out there. Can run in terminal. With hybrid working mode, one can have emacs in a tmux, and keep the same setup at home and at work. Extensibility, able to configure each and everything - never need to touch my keyboard while programming, lightweight, free, opensource and stable. packages and elisp Org mode. Completely changing my life as a grad student in mathematics. Extensibility, community, and FOSS nature. I can rely on it, and the skills I learn I will carry with me for the rest of my life. Because of it's age, extensibility, and great community, I see a lot of great ideas appear in emacs first. For example, it's the first place I've encountered Leader key navigation. Other great apps, like Anki, started as an emacs package. And there is no better task manager that lets me control my data than Org Mode. flexibility achieved by using lisp The ability to tap directly into editor internals with Elisp is incredible. I use VSCode also and I STILL keep Emacs around for "real work". It has everything in one package, in a consistent way extensibility, packages for many problems M-x interface, potential for great adaptable documentation, great vim emulation (lol) and hotkeys with SPC as a leader key. Extensibility and ecosystem (libraries+community+documentation) It is cross platform, very configurable and reliable Deep extensibility with a large "standard library" of functions. Programmability (incl. Macros), extensability, availability on the platforms I use. Extensiblity, documentation One Ring to rule them all. The extensibility and the freedom to change it to my use case. e-lisp. macro. org-mode(outline mode) Inspect state, make changes as it runs The ability to customize whatever I want without it feeling hacked together Extensibility, packages, documentation, a perfect language built into it and of course the community :-). I love everything about Emacs except one thing. Extensibility, readability of lisp, emacs help system, tons of features and integrations Community, extensibility. Ability to evolve: pushing more functionality to packages over the years, LSP support via eglot, and the recent work on tree-sitter longevity, customisability, extensibility, community. elisp, extensibility, cross-platform support malleability
keyboard-centric control of UI
performance wrt to Electron-based UIs Being a live lisp machine elisp, org, magit, xommunity Extreme extensibility and vast package repository. AucTeX is a necessity for my workflow. Extensible open source and written in C which provides good performance I can make it my own Versatility. Easily customizable, lightweight, simple GUI. lisp-based extensibility Configuration as code and extensibility. It's easy to create a specific (basic) feature for oneself. mode changes light and extensible The freedom it empowers its users with; ELisp; its documentation; the Emacs devel team. It' extensibility. The large number of packages. Lisp machine aspect. Advanced features that work Desire to be explored Its easy enough to use on a Linux box. Thats all I'm really looking for. - text editing features;
- works in the terminal; Org, dired, ease of customization, tab bar mode, free software, elisp, emacsclient, ido, erc, EasyPG configurability, packages (tramp, org-mode, slime, ...) Extensibility, additional packages for everything I need Extensibility and being out of the way when required Flexibility, community, extensibility Really open source key bindings everything in one place Org-Mode and Roam. Backlinking notes with vim key bindings is why I use emacs every day. extensiblility with great backward compatibility self-documentation, packages and extensibility Org-mode. It's to be honest why I'm using it ATM at all...
Also magit (still making the transition).
Scheme mode for hacking on Guix. simplicity and customizability Orgmode and dynamic elisp execution Extensibility and abstraction. Emacs is essentially a customization platform, and something you can treat like a configurable work platform and interface. As the joke goes, Emacs is a great operating system and a decent text editor. Community, Packages/Extensibility, Elisp It can integrate with all of the fancy things that you could possibly want without needing to be an entire web browser.
It doesn't require the resources of the new things (save Sublime Text).
It lets me control the whole configuration and doesn't get in my way when I need to make things weird. Customizability. Packages. Simple UI. More keyboard oriented than mouse. I really like how easy it is to customize and I especially like how its free and open source. I'm still learning but I'm very interested in org-mode and being able to write nice documentation alongside code. Org mode was the feature that lured me in, the movement inside of emacs and awesome packages keep me in the system configurability and extensibility with elisp, community, variety of packages, support for many programming languages, lsp support, in-program documentation Ability to stay relevant over time, to adopt new packages, drop old ones - without being locked into a single solution that becomes outdated. stability, flexibility, and ubiquitousness Extensibility, modularity Flexibility, huge package library Efficient editing. Programming language support (highlighting, inventing, etc.), tool integration (make, tags), extensibility. Extensibility, openness, maturity, standard and consistent way of dealing with everything Highly extensible and powerful. Magit! Org mode! Extensibility, GUI app for text scaling, variety of use cases and work flows Malleability, org-mode and related packages (babel etc) community makes everything new work well. Completely uniform and powerful tools to work with text Configurability and the ability to have every tool I need in one place. org-mode is the reason I use emacs over neovim Keybindings, extensibility, customizability Emacs feels natural to me, probably because I've used it for a long time. I like the fact that it's able to be an IDE and a raw editor depending on what I want. Also, I type in Dvorak, and Emacs' keystrokes feel very satisfying with that layout. The customization options, org-mode. Elisp! Extensive and pervasive documentation throughout the application, being able to change *anything* you don't like or that doesn't work for you. The package ecosystem, and it's flexibility. It's ability to program itself and the willingness of the developer community to merge in new technologies such as tree-sitter and LSP Ability to check source / docs and redefine any Elisp function. Extensibility. Excellent and clear documentation. I use Emacs with EXWM as my X11 window manager, and in general think of it more as an application toolkit like GTK - it's a very good platform for building primarily text-based interfaces with shared keybindings and UI customization. It's longevity, you can rely on it. And it's relevance, whatever language you're using, you'll find packages to support it. The customization possibilities and the years of functionality and packages built by the community. Extensibility. I can make it work in different ways on different projects, which was impossible in Vim How orthogonal features can complement each other. Renaming files in dired, using occur-edit, embark, etc. It's a lisp core with an editor built on top. I can customize it on the fly. Extensibility, and by extension, fully configurable packages for everything. I haven’t had to change anything I didn’t want to, and could change what I did. Extensibility, the fact that "everything is text" in Emacs, great default packages. Packages and Community * query-replace
* incremental search
* tab completion of tokens/words present in the buffers
* query-replace honours existing capitalisation of words so tiger TIGER Tiger replaced will become wolf WOLF Wolf
* mark begin, mark end then copy/cut Extensibility, self-documentation, and stability. Having a working environment for decades that has grown and changed without breaking If you can imagine it, there's an .el for it Org mode, packages, extensibility Shortcuts, Buffers Extensibility, many good modes (better than vim plugins) Extensiblity and a unified idea that everything is text. It’s extensibiluty. Even though my grasp of elisp and emacs’ own APIs is poor there is so much out there in the community that I can still find what I need Longevity, Customizability, Flexibility, Community ownership Extensibility, quick access to documentation, and the ability to alter anything to your needs. Extensibility, large userbase and long history distinct from corporate control, strong community of skilled package contributors Extensibility and that it is custumizable. Additionally, I love the command centric interface. Documentation and introspection. Being able to see the source that a command does. Open, extensible, and the UI A lot of quality packages Extensibility and the ability to truly master the system via repeated use. You an ease into learning it deeply, and there are distinct advantages to doing so over time. Extensibility, stability, portability, code as the source of truth, embracing text as the unit of work. Brings a full extensible development environment to any platform. org mode and extension * Smart indentation, just press tab and Emacs always give the right indentation. I start using Emacs because Windows-based text editor never give right indentation especially for writing C/C++. Keybindings are very nice to use Customizatoin Scriptable in elisp, easy way to call commands with M-x, easy to evaluate code and read/edit/advise commands Extensibility and platform support. Versatility, TRAMP mode, packages Flexibility. If you know what you are doing, you can do just about anything Extensibility, community, open-source-ness A universal interface to the computer. As configurable and extendable as can be. reliability, robustness Extensibility and it's text-buffer driven interface (I love how I can Avy to any string of text on the screen) The fact that anything can be modified Speed. Fast key bindings and wealth of commands. Its add-ons like Org-mode It provides a consistent editing experience across multiple types of files. Macros, advanced editing Its extensibility and the surrounding community. Extensibility / Configurability Extensibility customizability Extensibility via packages. It keeps modernizing itself this way. Extensibility.
Very well honed features. All in one, extensible, introspectable, open extensibility & text as a “first class abstraction” Strong community, easily extensible magit, flymake, edition through ssh Speed of adopting new workflows, independence from the big vendors. Magit and treesitter Extensibility and freedom. Orgmode, Community, dired, tramp org mode, c++ mode, etc. Extensibility and a group of experienced experts. stability over decades run emacs functions by name (or fuzzy search) instead of keybindings. i cannot memorizy keybindings very well. but i know all the function names i use. Introspectability and self-documenting nature, as well as the extensive package ecosystem with constant innovation and fantastic examples such as magit. Extensibility, auto-documentation, active community. Extensibility, lisp Org, mu4e, calc, magit, It is fun to use! Every time that I think "how does this work?" or "is there a function for this?" I can inspect the text properties, the data structures, or the source code, and learn something intesting, and everytime that I think "hm, it should be possible to automate this!" I can write a short snippet of code that does something useful... with that I can alternate between the "serious" tasks that I need to do and some "fun" tasks that are somewhat related to the "serious" tasks, and that make me more inspired. Text as basic format. That it’s configured in Lisp and takes advantage of the code-data duality, but also that there’s a client-server distinction Elisp, MELPA, uniformity of experience across different modes/packages Window and buffer management. Ability to integrate with the OS, Org Mode, Extensible interface to function with LSP. great extensibility, keyboard focus Extensibility and UX consistency. The text-first user interface paradigm allows for unparalleled "ah, this works here as I expect" moments. customizability and keyboard shortcut-driven development Documentation, built-in features, extensibility. Incredible extensibility, strong integration with platform and tools, TRAMP, presenting a consistent interface across platforms Flexible keybindings, contextual menus and strong control of terminal screens. Custom & Extensibility speed of editing Customisability, package ecosystem, canonical GUI Extensibility, live modifications to running environment org-mode, magit clean design, running on both CUI and GUI, extensibility Community and performance Extensibility, self-documenting, lisp based Configurability and extensibility. It takes a certain (flawed) personality to require tools to work the way you want them to and never settle for someone else's sometimes better idea. People with this personality will never be able to leave Emacs. Extensibility + Simplicity. Hackability, Keyboard driven interface, Shortcuts Freedom. Encouraging users at the outset to customize the editor to their individual preferences. The ability to easily introspect and modify *any* aspect of the editor. Ethics, extensibility, package ecosystem, stability, documentation Simplicity, great range of actions, community Extensibility and adaptation High quality packages very customizable, works exactly the way I want it to org mode; community; Describe something, change something. Introspection powered extensibility with Lisp Extensibility/customization and the great community of users/contributors. It's transparent and self-documenting, that's what makes it stand out to me. Mature community and major plugins such as org mode and magit The repl That it stays alive all these years (old) yet still very extensible and with many active projects. Also the fact that you can do almost everything in Emacs. Great text editor org-mode, extensibility (which mean nearly everything can be done in emacs, which create a very unified daily experience) There is a package for anything and it is streamlined by generations of users. Refined extensions that work well with the rest of Emacs. GUI allows inlining images. Keybindings fully customizable. Documentation easily accessible with C-h on anything. Functions easy to discover. The binding keys to functions. And the use of a high level programming language for writing those functions. Although I still regret the rejection of the modernisations suggested by the XEmacs project. Extensibility in a powerful language
A thriving library-writing community Extensibility, consistency, packages, org mode, availability on most operating systems. Uniform Text-ui interface - a community of enthusiastic and skilled programmers
- lisps are great for scripting everything
- self documentation and transparency Using a single tool for many purposes which minimizes context switching and allows me to integrate workflows instead of needing to switch between half a dozen different proprietary apps. stability, longevity, customizability and non corporate owners. Nearly all other software in my life has eventually sold out, died or broken critical things... except emacs. - programable
- packages in general That one can configure anything with Elisp. All of emacs' greatest strengths come from the fact that the whole thing is a programming language runtime and is arbitrarily scriptable. Org-mode and the general package ecosystem Extensibility; the fact “user extensions” are on the same level as “built-in” facilities and ability to evaluate code in a running emacs & see it immediately take effect It's rich package ecosystem. I often think "I'd like to see X for Emacs" then do a quick search and find there's already a well maintained package to achieve the same thing. - extensibility
- customizability Community, Extensibility Integration with various ecosystems It works and you can expand your knowledge Things that you expect to work, there’s always a way to do them in Emacs. Ability to reuse, override everything from built-in to external packages. Extensible, self documenting, open for modification, great packages Org mode. Evil mode. Dired. Complete flexibility for the user experience, powerful built in extension language Can do everything. Easy extensibility and customizability. No-mouse usage. Can be lightweight, if needed. It works in terminal. Flexibility, extensibility, lisp There really is a package for everything, and few barriers to adding your own functionality if not. Even after decades of development the project is still fresh and evolving, a jewel of free software. Discoverability (e.g.: built-in documentation, jump to implementation of Elisp function/variable)
Easy to fix/extend things
Does not force me to use proprietary software The customization ceiling is really high extensibility, introspection Extensibility and packages, you can make Emacs be the environment you want it to be, whether it's an IDE or for writing prose or both. Or just use it almost like an operating system.
Also I should add Org mode, that's what I use now for taking notes and as an agenda and I'm not coming back to using other solutions. elisp, terminal mode Lack of corporate shenanigans. Emacs's competitors can reach and overtake Emacs in many other areas, including its strong areas, but not in that. Extensibility. The ability for packages to integrate with and extend builtin functionality is unparalleled. Extensibility
Community Online documentation - Extensibility
- An actual programming language for configuration, customizatiin and extensions
- Comunity. The ability to modify and run packages without reloading the whole editor Extensibility and being a single tool for "everything". Its built in help system. That emacs can be adapted to pretty much any use case. So much in fact, that I know with extreme certainty that I will use emacs even if I stop coding in it. Also that you can express any whim at it and it will accept it. High quality packages like for example magit. Configurability. discoverability, configurability familiar environment for different tasks It is a fully featured Lisp IDE Extensibility, longevity leading to many packages Being a Lisp interpreter Introspectability
org-mode Support for diverse present and future domains and composability with external tools Elisp, full keyboard operation. Integrated help; broad and deep extensibility; completeness or maximalism (vs Vim); some minimalism (vs IDEs); its longevity and the perspective that brings; being willing to modernize in some ways and upholding its traditions in other ways The ability to extend using various defaults. I think emacs' greatest strength is that everything is a buffer. The face that you can use it as a coding environment is incidental. That is not to say it the coding environment should be. Besides being the great editor, it can be used as the keyboard-driven UI for almost anything. It's a Lisp; it's Free Software; the community around it; some great packages such as Org. - Keyboard shortcuts.
- Really open-source.
- It works (very few bugs, not spending my time on a bug tracker is a good thing for an editor. I tried PyCharm and spent my time on their bug tracker). The architecture as a programming language with some built-in text editing functionality extensibility and Lisp interaction The whole concept of living runtime, and that a keystroke is an event than can be captured by any mode, to provide a graphical interface used with buttons. Extensibility and customizability as well as community culture that promotes writing packages that are oriented towards customizing architecture Multiple buffers. Never have to use a mouse. Speed of development. extensibility, configurability (due to breadth of packages available) extensibility, discoverability and lisp It will live for a long time and nobody is telling me what I can and can not do with Emacs Extensibility -- most importantly, the interoperability between its extensions (e.g. automatically connecting email/scheduling to org-mode) Working with Keyboard, org-mode Consistent interface across platforms and across releases. Turing-complete extension language. Keyboard Macros elisp, not unix stuff Macros, Extensibility, Available Packages Speed of operation and use Stability and extensibility Gui Total programmability Customisation, self-documentation, freedom Extensibility. Chording. Breadth of commands -- so many commands immediately available. The emacs-lisp interpreter extensibility, simplicity, durability Many Built-in features that make you live in the editor regardless of the os in use Stability, extensibility, org-mode and the ability to use vim bindings Easy to configure, also Lisp - Lightweight out of the box but lots of 3rd party packages for additional functionality
- good initial key bindings great customizing by elisp. great krybindings. Programmable, and highly consistent experience Extensibility and portability text editing capabilities Extensibility, its open nature Incredible flexibility; and the fact Emacs is community-driven project, it's not depend on single company or mantainer extensibility, customization, been there for a long time can do anything The large amount of built-in function (e.g M-x butterfly) The extensibility and flexibility, Emacs is more of an operating system rather than a text editor, which no other editor can offer. All of the flexibility and functionality that is just there, esp. with text related modes. I used to write a lot in LaTeX and docbook. I could be productive just by scratching the surface of emacs and (for example) AUCTeX. - Built-in elisp, facilitating customization and package writing
- Huge variety of excellent packages (both built-in and external) Extensibility and orgmode That you can do almost anything in it. Quite literally. The incredible flexibility and wide ecosystem of packages. Being able to easily add custom commands and keybindings. Whole workflow in single window Org roam, packages Extensibility using a language that is little less esoteric than vimscript. extend-ability Org mode, note taking, easy capture and integration into programming/thinking workflow. flexibility and all the packages Extensibility, The fact that as long as it is a computer of some sort, I can install Emacs on it.
Also the fact that, although it is not always wise to do so, you can do almost anything from withing Emacs. Personalization. It by far the most personal experience i ever had the code which i write in config works as it is build with that functionality. Ethos of freedom, philosophy of connecting computing tasks and workflows together in a standard way I don't proselytize my computer interaction habits, so it's not something I've thought about. The package library, the ability to use it as a terminal multiplexer, TRAMP. extendability Org-mode, extensibility, easy to write small add-on functions, self-documenting - Extensibility
- Communities(s) Keyboard-based inputs are the best - emacs has excellent, customizable, chainable keyboard bindings Stability, extensibility, functionality. It doesn't hide what it's doing. Being a running Elisp interpretor, not just a text editor. This means you have the full, interactive langauge features to back you. As a glue between different programs.
Powerful editing and search tools Configurability. org mode, ecosystem Extensibility, simplicity (compared to say Visual Studio or VS Code), stability Cultural values. It has consistently gotten better over time. You can use Emacs for many thing including coding LOL Powerful text-editing features
Extensible, with a mode or package for nearly everything I encounter (new)
Editing files remotely (via tramp) Lisp REPL, extensibility Modularity, aim to roll your own distro 1. Of course, this is programmability in Elisp.
2. Organization of the program interface.
3. Ability to work both in the terminal and in the graphical environment. The ability to do almost anything (bringing in all sorts of tasks in a familiar environment). Forces you to become self-sufficient and fix things on your own. It works everywhere, abilities I learn are likely to still be useful 15 years down the road. In contrast, Colleagues who used Eclipse switched to IntelliJ and are thinking about switching to VS code. That’s two sets of editor-skills mostly thrown away (which causes the usage to become more primitive, focused on the absolutely required features). Single environment for everything... coding, writing, org-mode. Extensibility, Linux interfaces, keyboard-driven interfaces to git, docker, file system etc..., all-encompassingness, Adaptability. Good trade-off between evolution (adding new features) and stability (not breaking old ways). Extensibility, ecosystem, buffer platform, magit, org mode The extensions: magit and org-mode were life-changing Costumization, elisp, org-mode, magit Extensibility and customizability, macros, buffers for running shells The community that continues to improve it Org mode
Extensibility I’m mostly here for Doom emacs’ curated packages & config ergonomic The Lisp Runtime There's always an existing option for anything. Extensibility, org-mode, keybindings For me it's the org-mode and vhdl-mode. While VHDL is not software, for us HW people Emacs and vhdl-mode is a brilliant combination. Due VHDL's nature, there are very similar things (entities, instances) and the vhdl-mode can convert between these two handily, instead of the user copy-pasting and then editing. Customisable to how I actually want it (not just to someone else’s limited subset of possibilities). Integrates well with host environment, so I don’t need to keep switching to and from an editor depending on which task I’m performing. Cross-platform and able to copy my personal preferences around and use them anywhere. Being worse than vim Powerful prose editing, good exporting, customisability for diary-keeping, work-tracking, etc. By far, it's configurable and extensibility packages! magit, org-mode especially. Its Ergonomics and Usability, at first and by far.
Being Self-Documented is very important, as well as being (e)Lisp-Extensible.
Finally, it has packages for virtually everything.
The community is also great. Great developers and great people. Really rare combination IMO. User contributed packages (melpa in particular) Customize and Using Functional language like Lisp Emacs is very stable, the user interface is logical, even if it is not like other programs at use. It has very useful features and allows a lot of customisation. It offers very useful tools for my work (Orgmode, magit, Auctex, org-ref). There is also a community of intelligent and engaged people, who builds useful packages , shares customisations and explains it's uses for people like me, who are not programmers and have only a superficial knowledge of programming and software. Also, I work with emacs since almost 20 years, and I think is very realistic to think that I can work further with emacs during the next 20 years – without losing the capability to edit my oldest files. For the work that I do, no other application can promise this. Extensibility, inspectability ORG MODE. I love org mode so much. Extensibility. Stability. Packages. 1. flexibility
2. extremely well documented
3. org-mode org-mode, slime, packages, extensilbilty Everything is text, all the source code is there, running in the editor. Being able to focus at the task at hand, doing everything with keybindings. Not having to rely on clicky GUI elements one-app-does-everything: email, agenda, IDE, etc. The fact that it's configured in the same language it's written in, and that that language makes it really easy to introspect and change packages other people provide. I think that most other cool things about emacs (even killer app packages like magit and org-mode) are downstream from that. extendable in a easy to learn yet powerful language. Extensibility, freedom (from an extensibility perspective and also as free software) Extensibility, adaptability and the community. I have found a set of packages that suit my workflow and they make it very for me to work on complex problems. The editor does not get in the way of my work, and I can focus on the problem at hand. magit
orgmode combined with mu4e (I run a davmail/mbsync/mu4e stack, vital for keeping on top of my job) Not sure - probably the packages, extensions Speed, tooling (magit, projectile, lsp-mode), offline use Well-structured config, TRAMP, byte-compiled config API stability and extensibility. Elisp programming language. I'm not sure. I honestly use it out of habit now. I think I stick with it primarily because I'm used to its keybindings. Extensibility. It seems that whatever other editors come up with can be mimicked in Emacs.
Personally, I also enjoy the longevity. Emacs is much older than I am, and I hope to never use another editor in my life. "Cool" editors seem to rotate every 5 years, see the list above, and many are dependent on corporate sponsors, e.g. the decline of Atom. Extensibility and awesome packages I like that it has a strong culture of self-documentation and interactive exploration. It helps you learn how things work, and it's also extremely extensible. - Stability of innards and key bindings and careful evolution.
- Source code availability.
- Can do almost anything text-related inside Emacs.
- Lots of packages provided with default installation, mostly high quality or at least working well.
- Package system. The abudance of packages that just work History
Hackability Extensibility, paradigm consistency (it's just a bunch of buffers) Vim keybindings, great packages, customization Better customizability and org-mode + org-agenda Large community and adaptability Extensibility, Org mode, EXWM speed, availability, configurability, freedom Extensibility, my own configuration that I tailored to my needs. Interfaces for different programs in the same environment. Focus on freedom. (Full) Extensibility in Lisp. Extensibility, the built in help (where you can quickly go to the code implementing some command/function, and even modify it). Easy editing of documents without leaving the keyboard. I really miss to easily jump in/between documents with a single keybinding in other editors. Org mode is very useful, EMacs is also supported on many operating systems. It is more than a text editor. It is a total programming environment. The built-in help and the brilliant community packages, tramp mode Extensibility, great community. freedom, stability, interactive extensibility, everything is text, macros + elisp, introspection, extensive documentation, enthusiastic package authors, fantastic maintainers. Emacs is live programmable, designed to be extended as you use it. Extensibility allows customizability and good integration with other tools. Wide variety of high-quality packages. Keybindings and available features through packages. No need for mouse It is convenient to write function to simplify my workflow The programming environment. living in emacs (org-mode, calendar, mu4e) I found it easier to configure than vim, with a better ecosystem of packages (that include evil mode), Adaptability, emacs outshines vim as the complexity of packages grows and the user’s desire for more diverse functionality increases. Also the help system is unrivaled. Free in all meanings; longevity and permanence; flexibility; expandability Being an "operating system". Compared to e.g. Vim, I can use a coherent set of "apps" in Emacs that share similar keybindings, themes, interface, and conventions. Compared to e.g. Sublime or VSCode, it's less "project-focused" and thus more amenable to jumping randomly around between different local projects (e.g. various Org notes, Python code, LaTeX paper, config files) and remote projects (e.g. using TRAMP to connect to remote servers for long-running computations and inspecting the results). Extensibility, discoverability, millions of useful features You can replace or extend any behavior to fit your need. The wide number of available packages for every little thing. documentation All, documentation, support an info online , the culture an the ilimited posibilities that it gives.
I love *scratch* 1) Emacs is one of the most extensible programs ever 2) The GUI is designed well - it's there when you want it, but stays out of the way when not needed It is an integrated computing environment Truly open-source without big corporations involved. Well established and mature, you can make almost anything work in Emacs. It's been around for a very long time and will not go anywhere, hopefully! 1. org-mode
2. extensibility It's geared towards hackability. Lisp helps, but also you have hooks, advises. Also it features many useful abstractions like modes, keymaps, buffers, that just make it nice to hack and work with text. elisp turtles everything is text files Extensibility/programmability; M-x shell; org; built in modes; operating in terminal; completing read; magit It's extendability and customizability Freedom, customizability. Longevity and customizability evil-mode, emacs-lisp, daemon/client, emacs-mode(without evil-mode), eshell Support for many languages - Extensible
- Free software
- I can copy my config from my personal computer to my work computer and have it "just work"
- No spyware
- Versatile, can do many things
- Can move seamlessly between my projects with few keypresses
- Great frameworks available with batteries included Both its extensibility and its self-documentation Ultra minimalistic UI capabilities its extensibility combined with its community Its extensibility with the power of Lisp. Extensibility, packages, community. Everything can be done in the editor, don't need to use a mouse Extensibility and the community and its packages. Totally introspectable and extensible Org mode, magit Depth, extensibility, documentation Consistent text manipulation combined with so many packages and contexts to use those commands. Extensibility ,OrgMode, Community discoverability, extensibility That it doesn't force unwanted changes on me and that it won't disappear one day. I have a stable environment that I can trust for over >28 years now. Opensource It's modularity and extensibility to the users disposal community, flexibility Orthogonal my apply concepts. Everything being buffers. Possibility of nested usage of customisations. It's not vim Extensibility, high-quality packages, ability to work inside a terminal Malleability! The fact that it can be modified more than any other software in the world is its greatest strength. Doom Emacs is comfy. Magit, org mode and the daemon setup are major advantages. Extensibility, thriving package ecosystem Terminal (over ssh), Org mode, Customization. Great suite of packages, extensible and fast. Magit Everything is malleable, and it's easy to peek under the hood to understand how it all works. - Straightforward extensibility. If I need a quick function, I just write it in the scratch buffer. If I need it for later, I save it somewhere. It's the main thing that keeps me away from VS Code, honestly -- there's just no simple path from "huh, I could rig a ten-line helper function for that" to "I got this helper function here forever".
- Macros! I know multiple cursors are all the rage now but I find macros a lot more powerful.
- Excelent documentation. The reference manual is great, I rarely need to google how to do anything with Elisp. Longevity. Lot of software comes and goes, Emacs is always there. Individuality. One can truly build one's own tool and knowledge base world. Community. There are so many great people out there improving it and helping others. Package ecosystem, org-mode package ecosystem, lisp evaluation extensible, stability Cross platform, configurable, extensible, widely supported by packages, fast, native, Lisp Everything is text; everything is extensible; elisp is mature It does not have any artificial limitations on how to edit or read text, works with every programming language including plain text, and is easily extendable. Emacs is the best text manipulation engine. It's designed from the ground up not to be a populist text editor but a do-all interface, and it has held up. It set a very good demarcation between interested one-time users and fully invested long-term users. This has led to the development of awesome tools that put usability first, and hence enable customization (and as a result, A E S T H E T I C S). Plus it's open-source and built well.
Emacs Lisp is amazing, and writing packages in Emacs is a breeze. Text Editing is obviously world-class but I like how it can also integrate with practically anything else on your system (or somewhere else). Nothing else compares. Stable and very powerful, incredible packages such as magit and org-mode, can be fully customized. Integration of most of what I need. keyboard macros are a little-upvoted feature perhaps.
Overall, I like that the system is stable and my configuration has evolved over decades, none of the individual changes were particularly jarring or breaking. The level of extreme extensibility Emacs has covered a lot of ground in its years of existence and I think other editors are making a lot of neat chnages and forcing maintainers to do interesting stuff. But overall emacs is just the most extensible and you can form the tool to you, not like anything else really I actually like the keybindings, but I have keyboards with thumb clusters (e.g. kineses advantage 2).
Extensibility and package ecosystem are important, too, so that it can lint, etc Flexibility and extensibility. Great builtin tools like org, occur, dired, ediff calc. Extensibility. Shell-mode/comint-mode Auctex, LaTeX support, LaTeX Being free and open source software, stability, interconnectedness of all the different parts org-mode, it made me fall in love with writing. extensibility, decent language - Hackability and transparency (open hood). Effective and practical software freedom.
- Ability to reuse Emacs skills for many tasks Org mode, extensible. all the things you can do with it - awesome and it never gets in your way Buffer and lsp now Lisp, customizability, community Emacs is a truly malleable tool. Anything you might want to do with text, you can do in Emacs. You can write code or create macros on the spot to do exactly what you need. You can acquire a package of capabilities developed by someone else and include it in your own setup. Emacs is a workshop for text: you can customize it over the years to fit perfectly with you. The learning curve is also quite comfortable; I was able to develop my skills in Emacs piece by piece, learning it the way I would learn a language.
On that note, I see the interface as Emacs's greatest strength. Every action is a named command that you can bind to any key combination, or simply call as needed. Indeed, every one of those commands has code and documentation that you can examine right in the editing context. You piece together actions to reach an objective the same way you piece together words to form a sentence. Other software is a maze, where you must navigate layers of menus to perform any special action. With Emacs, you can identify exactly what you do often and make those things easier for yourself. Hackable -- there's a reason why Emacs got stronger LSP functionality before Vim.
Usable in a terminal Extensibility and Org moving around text with keys and bulk editing Its community. I love that it is fully free (as in liberty), and that people can help make incredible things with it. It's extensibility and fantastic packages, org-mode and magit being the two must-haves That it is extensible in a reasonable language - elisp is much easier to work with than vimscript. Extensibility, configuration language is language used for writing packages Easily hackable. Adaptability and consistent cross-platform use. AucTex
Flexibility 1) You can always trust emacs to work! It's fast on any computer and always works the same way.
2) The huge array of packages let it compete with professional heavyweight IDEs in many contexts Extensibility
Org!!! Keybinding system which combine chords and sequences and allow us to use all features without mouse which is amazing for laptop on lap Dired packages, ecosystem, cross platform + terminal GUI: SVG support, Menu, etc. It evolves while staying the same. Extensibility. The documentation system, e.g. describe-function and jump to the code. org-mode and documentation extensibility and consistent behaviour, interactive help timeless The unparalleled extensibility, packages and customization I can live there. But also Org-mode. Supreme customizability! The fact that the whole system is basically a live Lisp REPL, the amount of packages, Magit, Org Elisp, Server/client mode, packages Portable configuration, extensibility, mouse-less keybindings Everything can be changed to your liking. Amazing packages Extensibility, endless customization It's a lisp machine built into an editor. flexibility and textual user interface Lisp machine. Existing infrastructure. Existing community. Values (i.e. FOSS etc). Better than terminal at TextUI. Old enough software to be written for slow machines, i.e. efficient. Extensible, consistent, can configure literally everything elisp - extensibility Extensibility, availability, customizability Extensibility, and keyboard driven editing. Free software, vibrant community, elisp interpreter I can perzonalize it Extensibility, can be made into anything and configured so that it works for me 100% Flexibility, extensibility. I love org mode. free, extensible in a lisp, synergy by using it for everything, keyboard driven, magit, tramp, org-mode, completion (vertico, helm ...) Available packages, everything can be customized while staying relatively performant Its extensibility and flexibility are amazing. It speeds up both software development and writing. The merge of 'what I want' and 'this is how emacs works' leads to undiscovered and unexpected efficient ways to work. Emacs is a platform to build custom workflows and bring most productivity and creativity tasks under one roof. Its friendly and helpful community. Its self-documenting nature which makes exploring new features possible and easy. Extensibility and the available extensions (Org-mode and Evil are the must haves for me). It's the editor you want it to be, with very little in your way to making that dream a reality (except a large time investment). Lisp, Integration Extensibility through plugins - magit, org, etc... Being an customizable, extensible super-app for the Desktop aligned to user interests Elisp, dedicated developers working to improve it Growing with the user over time and discoverability. Libre
Extensibility & Customization Freedom and programmability. It works Extensibility, discoverability, community The cohesiveness of the environment: Everything is customizable, even to the extent of fully replacing existing functions at runtime via advice; and that many of the packages are top-tier in their domains. Magit and org-mode especially. They're what got me back into emacs after several years with vim and vscode. No difference between an external package and an built-in package. New features are not just "tacked on" or restricted to a limited package API like with some IDEs or web browsers. Customizability, Live Lisp environment, Ecosystem, Community customizable, documentation, easy to grasp source code, community Personnalisation, extensibility Flexibility// ability to integrate it with pretty much anything Extensibility? Emacs Lisp layer. Ability to adopt new editor features without compromising core architecture and core interface principles. Fully keyboard-driven usage possible. No need to remember rarely used key-bindings: just use the command-line (M-x) — even more powerful with which-key, ivy and counsel. Internal help (describe-*). Many cool packages. Supports (almost) all programming and data languages. What has been leaned in one (major) mode will work in others too (most times). bash/shell uses same key-bindings for line-editing. The extensibility, and package community. Free, extensible and Org-mode - extensibillity
- easy to debug (or deactivate) bugs
- many packages -> can be use to do a lot a stuff others than text editing (org-mode, mail,..) Simile dependable functionality keyboard macros Extensibility, Portability, Org mode, magit, dired. editing, magit, terminal mode, tramp Built for keyboard shortcuts, fast, encourages 'finger memory'. Community of people doing truly innovative things and in it for the long term. Org mode, roam, Window system, tramp, excuse to write lisp Extensibility, LISP Dedicated community, great packages, portability and configurability Efficiency, minimalism, control. Extensible, free software, lisp machine. 1. Can use TUI in a SSH session
2. magit my favorite thing about emacs is org-mode Extensibility, being able to look directe at the source of each called function The extensibility - emacs can be extended to be however I want it to behave. - Fully extensible by a "real" programming language
- Several talented hackers have deep thoughts on code editing technique, and created great packages based on that.
- Emacs itself and almost all packages can be used without mouse. Killer apps like org-mode Extensible, customizable Extensibility and configurability of said extensions Longevity/resilience. On-the-fly extensibility. Extensibility, configurability and compatibility Aside from extensibility, I think its introspectibility and self-documenting nature is huge. It's usually the first thing I show people who are curious. free psychotherapy Extensibility, free software, great documentation, community, and sheer power at your fingertips. I see emacs more as a lisp runtime and framework, with display capabilities, than a "traditional" text editor. Extensibility, Elisp. The fact it's a programming environment extensibility, it's license, magit. being able to write my own functions and modes, consistency over many modes/applications It offers a unified framework to work on any project (programming, running scripts in shell, writing in latex, etc). It allows to work remotely via terminal interface. If I know how to use any feature, I already know how to tweak it. It's very empowering. There's a very small jump from "user" to "hacker". IMO most people can't code because most systems that they interact with aren't as hackable as emacs. The emacs community and it's extensibility. Unlike in the vim community, it is encouraged to use plugins and create/extend packages which greatly alter the editor, making it truly a great experience for everyone it uses. The extensibility and flexibility. Besides being fast and very complete in terms of features. It is a uniform interface to a large variety of applications. easy to extend. Extensibility, lightweightness, ELisp Extensibility & customizability, great and active community projects/support. Note taking in org mode, magic, free software principles. Longevity and stability. Great packages like magit. Extensibility, being GPL licensed. It is miles ahead of any other program in these regards. Strength of the community and the wealth of packages Org mode that can invoke scripts in various programming languages. I use that to write repetable test cases.
Text editing is very powerful. All: org-mode, lsp, debug ... * Great user interface
* great extensibility
* it's a live Lisp environment It's customization potential native keyboard support for everything
Magit! That for most of the day you don't have to "leave" emacs. Hackability/extensibility/composability -- all aspects of the same thing. Basically, the way that Emacs builds/can build on itself as one uses it. it's flexibility Most of it is written in elisp, which allows it to be self-documenting and easy to extend.
The possibility to communicate with external programs quite easily.
Dired, org-mode. lisp interaction mode for easy calculation Extensibility, flexibility, portability Completely custom configuration and bindings. Easy automation helps too. Extensibility and everything’s a buffer. When I see a VSCode package hasn’t been touched in a year I think “oh no it’s abandoned”. When I see an Emacs package hasn’t been updated in 8 years I think “it must be perfect” Large userbase. Everything is text, everything is auditable/modifiable easily Packages
Customizability Featurefullness Org mode
Its extensibility "everything is text" interface Extensibility and Ecosystem, org-mode + org-roam OrgMode. magit, org mode Customizability, extensability, existing elisp applications and packages. High quality code base. Extension ecosystem, editing experience that works the same on any OS, FOSS Its philosophy of freedom. Configurability (starting from keybindings, to featureful packages) The ability to work really well with command-line tools by incorporating their output into emacs so it can be manipulated using standard emacs idioms Yes major and minor mode can be provided any prog/text-based language. It's extensibility. It's really extensible and is an awesome platform for text based application. The only thing that's missing is a really good text editor. Customizability, cost, longevity. Editing text on a remote server for system administration was the killer feature that moved me to Emacs - Open source
- Community-made packages Integration of text manipulation across e-mail, PIM, programming... letting you create a complete programming environment - akin to an IDE, but much more customizable Extensibility and openness. By treating everything as text you sort of get a microcosm of the Unix OS editable entirely with key commands and cording. Everything is a function, keybindings for everything, window management for splitting and moving around Keyboard macros - main reason used for many years - now useful packages Customizability, reliability, lots of good packages/modes included in vanilla distribution. Packages, extensibility, community, keyboard movement. Self documenting
Elisp - extensibility It's fully customisable Org-mode
Flexible Documentation, programmability. Package support for many languages and tasks Extensibility, hackability, this makes Emacs both extremely powerful and *fun*. Also, being free software and text based makes it worth of long term commitment and investment. Extensibility, great community, light-weight? Org mode. The good documentation and extensibility. Literally I can use one program to do everything I want on my computer. Org mode. Configuration and extending in Emacs lisp. Input methods to write different languages. Extensibility, tight integration with Emacs Lisp Org-Mode and the plethora of other packages. Extensibility, Keybindings, Package Quality, Org-Mode, Magit Its greatest strength is that it is one editor for every task. This comes from its extensibility, of course; you're not giving anything up to use Emacs for almost anything. Extensibility, documentation availability, thorough documentation Extensibility, lisp as configuration language Extensibility, community, managing somehow to stay up to date and relevant in the age of vscode, magit, org mode Coherence and longevity Global state (also it's greatest weakness). Ability to patch the world from your running instance and move on with your life, instantly. Can adapt it to do exactly what I want to do the way I want to do it. The ability to do multiple things with a unified keylayout and all programmed in elisp. Amazing set of packages.
Vanilla emacs is snappy It has been around for longer than me and I expect it to be around as long as I use computers. That makes it worth learning. No interface changes except those I control (assuming I understand the thing which I may in future years). It being a Lisp environment. Lisp & everything is text & community. Extensibility and the amount of packages Customizability, universality (generally good editor for different purposes), keyboard-oriented built-in functions and kbd macros That at heart, it's a Lisp interpreter. Ease of extension, ease of learning, and most importantly, org-mode. Community - there is a package for almost everything and multiple different implentations so you can pick and choose what suits your needs best. It being open source allow you to easily tweak it and then share it with others. No corporate involvement, a extensive list of packages Widespread async support. Commuity, malleability, powerful features It was definitely the best text editor I have ever used. It's keyboard center of focus Its powerful text editing features from a command line. Customizability, extendability, community, self-documentability, FOSS The fact it's STILL around while other editors (barring nvi/Vim/Neovim) came and went in popularity. Because of that, it will probably end up around for another century. Extensibility. Excellent existing packages like org-mode and org babel. Lisp is an excellent language for live interaction. It’s like the whole editor is a REPL that updates are applied to live. Exists for a long time and expected to continue to exist in the future.
Instead of jumping to the next new editor one can stay with Emacs. Extensibility, ability to introspect and debug functions, breadth of packages. Liveness, Extensibility, elisp, community, tradition, software freedom Almost entirely mode free editing, Extendability, Chording > Modes extensability Everything is done from the keyboard. I never have to lift a finger and can keep at the code instead. The extensibility and introspection capabilities. The fact that you can look up, modify, and then experience your changes in the same session is really cool. The possibility to have evrething that I need in one place. Text/graphical flexibility, programmability Customization. Features Using scheme to configure. More out of box experience. As far as my own use is concerned, Org mode is the best part of Emacs. Emacs-Lisp. Almost the same user experience on windows and linux, no need to change the configuration. Extensibility, every thing is a function that is exposed to the user, multiple platforms support It works with everything, and is very customisable (by existing packages if nothing else). Most editors have a niche. It is also very uncluttered visually, I can have lots of editor space easily and no annoying tabs / side panels etc. Everything can be bound to a key, extensibility Self-documented, all codes are open,
interactively interpreting code and elisp.
Customizable, extensible. Its extensibility, wide selection of packages and large number of users. Extensibility that allows people to build their own editor over time. Its ability to be bootstrapped by a framework like doom or spacemacs, as well as other flavors targeted at prose & nontechnical users. Lisp as the configuration language means you get better emacs as you become a better (lisp) programmer.
I also have ADHD, and being able to build my entire workflow into emacs to reduce cognitive load & context switching through the day is probably the only reason I'm able to keep up with my work. Org mode, terminal mode, documentation system It's fast and extremely composable. Knowledge learnt in one context is almost always applicable in other contexts too. Free, open source, extensible works great in both GUI and console mode, and elisp Infinite levels of customization; lots of choice when it comes to set-up, and distributions like Doom and Spacemacs are really good for people moving away from Vim. I love that I can come close to my colleagues' PHPStorm/VSCode setups but with an incredible keyboard-driven workflow that doesn't need a tonne of space on my screen. Packages, extensibility, community Resilience — it's been around for a long time, and it's likely to remain around for a long time to come. Extensibility — it adapts quickly to new trends (LSP), and although it's not always seamless, it works. Extensibility, Package ecosystem, Unbloated I’m just too used to the advanced keybinding to switch to something else, even though I think other IDEs are superior for my needs. Emacs Lisp is great, I use it to script refactorings. Also I like the package system and the ease of installing packages. A Lisp interpreter. Running faster also is nice. Command model + macros, available packages (ELPA/MELPA), specific packages like Magit and SLIME, community resources Extensibility : it is the closest thing to a Lisp Machine. community packages It's a wonderful program. Also, its customizability. The extensibility and the community, and it's open-source. terminal / daemon + low memory footprint It's like vim++ with doom Community! org mode; it is a revelation Emacs can be configured to be almost everything to everone. I'm a DevOps engineer by trade and needed mostly an IDE-like experience for Ansible, Python and bash scripts. Doom helped me a great deal towards that and the Emacs community in general is pretty quick in picking up new things like LSP, tree-sitter etc. Having a Lisp as configuration language makes much more sense than VimScript. simplicity. 'all is there'. Extensibility. I like that it's a lightweight Lisp Machine. dired
rmail introspectability and extensibility Extensibility via emacs-lisp; robust package library; stability (as in: emacs doesn't crash). It’s project management features It's speed - the synthesis of features that elsewhere require separate programmes.
- the possibility of people to collaborate on expanding what it can do.
- these two things combined. Keyboard driven workflows and extensibility. I see Emacs as a text-centric shell and like the "flatness" of its design and integration with packages: it allows for a multitude of connections of simple bricks which interact and reuse each other. Its other great strength is Elisp, and the fact that almost all code can be redefined while Emacs is running. Extensibility and the community of great packages The ability to customise it to do the most complex tasks whilst within the bounds of the tool that I use for other things Consistent key bindings, usable without mouse. Org-mode Extensibility, Elisp (especially for the interactivity it provides) Configurable, features, OS agnostic The natural idea of mapping functions to a series of keystrokes. Also, Emacs has very reasonable ideas about the relationships of windows and buffers. It additionally handles child processes acceptably well. - Being able to interact with REPLs inside the editor itself
- Org-mode for heavy-duty writing
- Good markdown support
- Be able to create temporary buffers whenever you want
- Consistent keybindings across different uses inside the editor Extensibility : many great packages (notably magit, org), and vim editing style The communit, and the extensibility and flexibility of the program, with or without packages. It's a lisp machine, not an ordinary editor. Very good built-in programs and capabilities, plus immediate feedback when configuring. extensibility/customization Extensibility and keyboard driven. Extensive set of key bindings, vast number of very good internal & external packages, simple to extend ad adapt to one's needs Efficiency, extensibility and portability. Extensibility. Optimal mix of UI and text editing capabilities. Packages such as org-mode. Customizability/extensibility Availability and extensibility A big library of extensions; scriptable text manipulation Emacs is very extensible and facilitates associating keys (key chords) to any/most actions. That prevent reaching out for mouse most of the time. It has a good balance between visual display and textual edits. not an IDE, multi-language support, text- and keyboard-driven interface Consistency over many years. Support for all sorts of things you might want to do with it. Packages. Nice community. Maggit its extensibility but for me apart from some python programming org is the only reason for emacs use. many packages Consistent design pattern and language that has been refined over decades. Extensibility and design, the idea of the “editor” being macros on top of some “thing” (lisp interpreter) is genious for extensibility! For me, it is that package management is built in, and so all I need to bootstrap my editor is cloning my config to my machine and run Emacs. I'd also say Elisp, the extensibility of Emacs is unparalleled. It’s extremely extendable. Many packages add tonnes of useful functionality, and yet stay true to the core of being able to do so quickly with minimal keystrokes. Its durability and extensibility. Emacs will always be there and with a little work, I can usually make it do whatever I want it to. default key bindings, extensibility Programmed and configured in Emacs Lisp, active and enthusiastic user community, huge selection of extension packages. Relatively easy to change anything. Nothing can be pet peeve in Emacs except for lack of pet peeves. Common interface between platforms (Unix, Windows, everything else) Being so self a documenting and being less an editor as a complete hackable system is incredibly powerful concept. Its like seeing the future of computing but receiving it from the past. The potential for working at the speed of thought. Change what you dislike being able to do anything, very well, fast Magit. EIN, eshell Org mode, Extensibility with Elisp and Elisp development evironment Extensibility, community, org-mode. Freedom. * Emacs works reliably on different operating systems without requiring configuration changes
* It's incredibly fast compared to many other dedicated GUI programs; everything is incredibly snappy and efficient
-> Notably, the browser eww can efficiently surf the web while on a 64 kiB/s connection; the same holds true for rcirc (for irc)
* It provides a consistent interface for numerous types of tasks
* It can be infinitely customized to suit one's needs, yet does not _require_ configuration Support for multiple languages, extensibility, keyboard driven control, terminal support Magit (the greatest piece of software ever written, IMO), extensibility, community Lifetime consistency, does not change with time, I can leverage things I learnt years ago. Also lightweight compared to Eclipse, IntelliJ etc. Everything. Shell-Mode: command-line sessions as buffers FOSS, configurability, community for default configuration and packages, second brain, predictable Matching terminal and graphical user interface.
Elisp. extensibility, stability Quality. GPL3+. Moderate but rewarding learning curve that keeps the IDE hoppers out. extensibility, community, quality, maturity The package ecosystem with support for everything under the sun, and the flexibility of running on the terminal. Customizable
Org+org roam+org agenda+org babel Keyboard orientation, packages like org-mode, org-roam, magit. full customizability Community + extensibility FOSS, customization, extensibility, stability, long heritage (also a weakness) The C- and M- usage. There are no editing mode like in vim. Also it has many packages. Good integration with hunspell. Great for Lisp Org mode.
Major and minor modes as a concept.
One editor for everything. No changing and relearning new bindings. Continuing dedication of the community Programmability - being able to create solutions to very specific problems in my workflow as well as dealing with the common cases. Emacs' greatest strength is by far its extensibility, followed closely by its community and the packages that it gives life to. The fact that it’s built on Lisp. This way, features are more integrated as everything is interfaced through Lisp. The ability to perfectly mold Emacs to your needs. The learning curve is steep, but it pays off handsomely once you invest enough time into it. Also, it is easy to inspect and get working the way you want it if something goes wrong. deep integration between things like mu4e and org-mode are just fantastic. Documentation and ability to tinker. rich community and plugins magit, avy-mode Extensibility. Client/server model. Visual feedback when interacting with it. Keyboard driven. Plugin system that doesn't make me cry. Support for almost all languages. Integration of various functionalities/packages, relative consistency (+ batteries included as far as Spacemacs is concerned) extensibility via Elisp Graphics integrated UI. customizable
Org-mode Longevity. Consistency. I can make it do anything I need… if I really need to… but core functionality hasn’t really changed that much. Mostly I just need to edit text files in similar ways and I can. Org mode. Old-school feeling, speed, simplicity. - Great editing features
- Good extensibility
- Reasonably good performance Every detail can be customized ! Extensibility. Scriptibility. I've come to rely on the fact that emacs isn't really a text editor, but rather an elisp execution environment with an okay text editor embedded in it. Extensibility, availability of packages, powerful default keymap, calc and org-mode. It's versatility and extensibility. Being cheaply extensible. Encounter an annoyance a few times? You can probably solve it permanently or semi-permanently in a half hour.
Self documentation and info manuals, however searching for content in them isn't the best or not straightforward. I'd like some sort of fuzzy apropos search across all manuals or one where you select a manual and can then fuzzy search.
The way everything fits together.
Great debugging facilities. Extensibility and the knowledge that it has been around a long time and will likely be around for a long time to come. Huge amount of functionality, discoverability (with helm), uniform key bindings across many different problem domains, and TRAMP. TRAMP! There's nothing else like it in the world, I looked, and it's what brought me to emacs in the first place. Editing files owned by other users on servers I connect to using my own user ... perfection. org good extension language, good set of extensions (dired etc), good set of text-related primitives Extensibility, especially the ability to change/advise any function innate lisp-based extensibility A framework I can hang anything into using specialized programs (perfect UNIX philosophy); limitless extensibility Extensibility and the ecosystem. A lot of possible workflows that can be implemented. Packages work nicely with each other, making Emacs an Integrated Desktop Environment (also, but not only, for development) Ability to get the exact needed and wanted functionality. Extensibility, packages, ubiquity, helpful community, "everything is a buffer". Community, ecosystem, culture org-mode, hackability Extendibility and flexibility. Its overall ecosystem: elisp code and OS usage Probably extensibility Extremely fast feedback for elisp, which makes extending it a delight! it can do anything you want, probably including controlling nuclear reactors. not that i aspire to control nuclear reactors. flexibility, coverage of space of needs, community, and learning a core part of system allows great power - very light-weight
- many packages
- having a list dialect as a config language Lisp and runtime programmability.
Keyboard driven. Meta-Slash Extensibility
Making your editor your own power tool that it's a framework rather than "an editor with an extension language added to it." Mode for everything, and if not, easy to make a new one Elisp access to all the things. Emacs as a whole, from being able to use org mode with org-roam, to being able to use dired to log into remote development environments. Emacs is really flexible. does EVERYTHING A large library of pre-existing packages Extensiblity, its documentation, stability, robustness Extensibility and packages. It's a totem of the free software movement and still keeps up with very expensive solutions like vscode. I hope we manage to keep this up. The fact that you can mold it to fit your exact needs, which can change over time; the longevity; and free software. Self discovery, extensibility Self-documenting, extensible on-the-fly, active and friendly community
Emacs is kind of the dream of what free software can be, when actually realized to its full potential, because it has these three strengths. The keybindings, the packages, and the ability to configure vanilla Emacs from one text file - init.el. Extensibility, configurablity, and documentation. Hard to explain but muscle memory comes into play. The number of times I use C-X C-f on other editors it troubling. Keybindings. It feels natural. Extensibility and package system Extensibility. Org-mode. Tramp. It does what I set it to do and what I want the same today as it did yesterday and I'm comfortable it will do the same tomorrow. When there are new things, I get to choose to use them the way I want, not the way someone else dictates. Extensibility, configurability, excellent package ecosystem Better syntax highlighting than vim.
General extensibility Speed of use, keyboard only possibility. Killer plugins. org-mode, magit, etc. flexibility; custom behavior fairly easy to implement Fast compared to other editors, configuration can be easily shared across computers, same environment for multiple languages, a package like Doom Emacs makes it easy to setup and configure. Simplicity but with Extensibility. Extendability and reliability The rich ecosystem of fully customizable packages (e.g. Org-mode, Geiser, etc.) A enormous packages curated by the community, the extensive power of emacs lisp. Documentation, community, freedom Emacs is a platform for LISP programs--an ecosystem, not an editor. High efficiency ceiling, configurability, many useful packages, centralisation & unification/co-usage of many functionalities Extensibility and all-round cohesiveness. Emacs is like a software Lisp machine. Extensibility, treating everything as text, large feature set. Ability to do everything, incredibly configurable. Extensibility and auto documentation it's not very opinionated and can be tailored to my needs better than other editors Extensibility and community-based Rich ecosystem integration Magit, org-mode, composability Based on text and standards
It encourages extensibility
Respects all freedoms
Teaches me better ways of doing things Ultimate hackability, solid community. Windows in arbitrary layouts containing arbitrary content.
Better performance than more mainstream editors such as vscode.
More extensible than vim—emacs is probably the most extensible editor I have ever used. Community and extensability Org-mode and its various packages. Expandability. With emacs you can change the editor to be however you want. Extensibility, and some really great packages built on top. Extensible. Extensibility, elisp simplicity The ease with which you can write your own features, and as a consequence of that, the community of user written packages that has grown up around Emacs Ecosystem and extensibility, and a rich GUI interface compared to vim Extensibility. I can tie it into any workflow The package ecosystem and the modular nature Hackability, configurability, remote editing, packages Online help, stability, and portability. Elisp! I love the fact I can modify right about anything. ability to easily customise and adapt to suit individual needs Customizable features, settings and packages. I see emacs as a programming environment with a standard library optimized for implementing text editing. This is exactly what I want as a programmer. It's multi-decade stability is something I've personally enjoyed a lot. Customization and the number of packages. The package ecosystem seems very strong. I think part of this is that it feels a bit more like a regular software ecosystem with dependencies and libraries etc, vim feels very much like plugins are all just standalone hacks. Also magit is absolutely magical. I am extremely proficient with git command-line but still usually prefer using magit for managing my branches. org mode
powerful community Self documenting, Extensibility, Light Weight. Its freedom and extensibility 1) Macros: any repetitive thing I can just turn into a macro
2) Being able to write functions and modify existing ones Emacs really thrives on its customization and extensibility features. I mostly use it for programming math simulations or formatting latex documents. Org mode, Slime and evil. Its vim with a very good note system and debugger Extensible syntax highlighting/programming modes. For pretty much anything I think I should be able to do within Emacs, it turns out I can.
Additionally, the consistency of using Emacs for different things makes work flow better. The editing. And all amazing minor- and major modes. The customizability and great packages like Org, Magit, lsp-mode. extensibility and just general power, was vim user which I love but its too hard to really twaek. Emacs is just "more" very happy with the decision to switch Extensibility. Configuration, macros and extensions as a same thing basically.
And Magit. Emacspeak, intensibility, packages Extreme customisability, extensibility, combined with backwards compatibility. Extensibility, documentation, ability to avoid using the mouse Programmability, malleability, Emacs Lisp Extensibility, org-mode, and focus on user-freedoms. The design behind major and minor modes portability, lean GUI, remote editing features, orgmode Everything can be configured. Very powerful commands for text manipulation that are easily available and searchable via M-x Extensibility, community support and Org-mode. I have to context-switch less often when using Emacs. full keyboard editing, and powerful extensibility. Working in terminal + extensibility. - extensibility (lisp)
- history/community (many things are already implemented and are easy to understand) Extensibility, simplicity, community, quality of packages Extensibility, lsp, orgmode, community Emacs is a platform on which I can process all of my text based workflows. This is an extremely powerful concept, as I don't need to context switch between different applications, each with their own settings and behaviors. On top of that I know how to extend or modify a workflow in Emacs in a way that I can enjoy working with it. its cool and configureable.
I like the no-mouse-needed approach Extensibility, ease of uses. Speed, and that its all text Highly Extensible, top notch feature set Amazing extensibility (especially the ability to advice functions), its introspective and transparent nature, large library of packages. extensibility/customizability, availability on a wide range of systems, community, free software Plasticity Open source and customizable Keyboard-first buffer switching One is able to do ANYTHING with it, and to tweak it perfectly for the personal workflow. Extensibility. Being able to program the editor, especially in a REPL style, makes it possible to tailor it exactly to my needs and wants.
The ease with which you can create new keybindings is amazing and really makes Emacs fly through files, once you get over the initial learning curve. How easy it is to extend and its documentation. It's greatest strength is also the thing that makes it so hard and long to get acquainted with it, that its invitation (via its documentation and being a lisp interpreter) to totally understand how it works and why Extensibility and lisp
The extension language being lisp is a synergy The fact that it works as a generic textual desktop environment, for which a number of applications is available that I can mix and match to achieve a desired end. The greatest thing about Emacs for me is that if I want something changed I know (from experience) that I can in fact change it to do exactly what I want extensible, macros Keyboard driven
Extensible When I used it for project management, I would have said Org-Mode. That's still pretty cool, and I use it to create PDFs from text files and to publish my blog. I also like Tramp-Mode. More broadly, Emacs can be customized and extended. I declared bankruptcy and moved to Spacemacs. I just integrated a package with Copilot. You can make it yours. Freedom, community, extensibility Extensibility, ability to run in terminal/text-only mode The fact that I can program in different languages using a single interface and the text features of ORG are great and allows me to move between platforms without being locked into proprietary text editing products. Using a LISP for most functionality and extensibility. Amazing packages, great community, continuous improvements to the editor with each new release Packages for everything
As minimal as I want Extensions, open source, not from Microsoft, text editing capabilities Extensibility and Customization to ones need. Extensibility/Customization
Integration and inter-operation with other tools (grep, git, ... ) Very good packages
Very fast text editing if you can touch type
FOSS I can use it without ever touching the mouse. I also don't need to switch apps because everything happens within Emacs! It's a whole Operating System :p, nah seriously it's the extensibility and flexibility of use The ability to innovate Its self-documentation, and more broadly the sense that it respects me and wants me to dig into it. Despite the steep learning curve, every part of it has a sense of inviting me to understand how it works. There's nothing else like it. Extensibility, hackability Extensibility, customization, small memory footprint compared to equivalent GUI apps for email etc. the adaptability for each user preferences Inspectability and self-documentation helps users learn to tweak things. It's FOSS Adaptability and (if this is a word) Scriptability Extensibility using Lisp.
Org mode. configurability, I can get emacs to do anything I want it to do
composition, I can hook together existing code easily, for example eshell integrates into shell scripts It's a transparent system, based on LISP Its documentation (and documentation culture) is supreme.
Also the package eco system.
Some personal highlights: org ecosystem, magit
And the way it seamlessly integrates in so many workflows/external software (e.g. tramp, mailing)
also street cred you gain from using emacs
and in comparison to vim, its extension language is way more sensible - It's open source and not tied to a company's monetary goals, so it will live much longer.
- I can use it on CLI, keeping memory usage low The compile / jump-to-next-error thing is my workflow. Speed. Flexibility. One-stop shop for all I need to do. The extensible self-documenting elisp environment Extensibility, buffers and magit Unparalleled extensibility and capabilities. easier to configure than vim Extensibility/customization. I can rig up functions to do anything or find a package to do it for me. magit, dired It's extensibility through Emacs Lisp, and the growing number of packages rewritten in more modern Emacs Lisp frameworks and whatnot. The community of users and developers is excellent as well! I love watching System Crafters, and the Discord server for that YouTuber is great, along with the Doom Emacs Discord server (even though I am a Spacemacs user). The customization and extensibility. I also appreciate the ideas of the FSF but I wouldn't say I am a die hard believer configurability (evil keybindings) having clojure-mode, cider, magit, Being able to run Emacs in a terminal is one of the primary features that keeps me on it over other alternatives. Knowing that the development environment I am most used to is available for me when I am in most remote server environments is nice. Also, it keeps a lot of the usual clutter you see with other text editors out of the way. When I used VS Code in the past there were features that required I use a mouse to mess with UI layout each time I used them, which was very annoying. It's a comprehensive interface to my computer, fully live-configurable using a sane language (elisp). Configurability, terminal editor Emacs is extremely extensible + it's text editing features are really great and the world has never seen a better document format than org. Extensible with emacs-lisp Extensibility, consistent UI metaphors An all-in-one environment, without relying on outside programs (e.g Tmux).
The ability to use Vim bindings for editing.
Integrated Terminal access.
The ability to run as a persisted server process. Even if I log out of my server I can reconnect and start off from where I left off with all my open buffers and processes. Extensibility through Lisp Ease of understanding, good documentation Customizable, standard for functional programming. The built-in major modes/tools are incredible. I use org-mode, occur mode, calc, and the calendar on a daily (hourly!) basis. Other extensions, projectile or helm, just make that value proposition Extensibility with eLisp. Lot of functionality under the hood. Org-mode is very useful (I'm still learning). New LSP support (with eglot) is something I will love to try. It's fast and stable and not really owned by a monopolist it is quite extensible and customizable. Core + everyrhing else in LiSP Built in documentation.
The architecture enables project management. Shaping it to fit the user's needs exactly, built-in tools (Magit, Org-mode), package variety, starter packs (Doom) extensibility, self-referencing, inline documentation Extensibility/programmbility org mode, flexibility as an IDE Extensions, Elisp, community, a platform for all things about text Wide library of community code Extendability because of elisp 可以完全使用键盘操控 Magit
Extensibility The choice of a lisp language to extend it. The mode system. No need to switch tabs to another window which can lead to wasting time. Dired, org, are my favs. Org to PDF is very good. Org is my TODO list maker. Extensibility, org-mode. Elisp capabilities and extensibility. Text editing, customization extensibility through elisp; community Extensibility and eco system Integration of environments without the sluggishness of other IDEs The sheer size of its ecosystem. Total freedom. It does not enforce anything on the user. You can do what you want with it and if you don't like something you can change it to your liking. its possible to config on the fly Open Source and fully customisable with a lot of built in power. Extensibility, macros, great key bindings, ability to write powerful packages/programs in it. innovative features (only emacs would have something like symex.el) I would say elisp is the foundation of "Emacs' greatest strengths". Everything can be changed extensibility and existing/new packages via that extensibility Extensibility and key bindings. Extensibility, depth ON THE FLY Extensibility. Self documentation Extensibility! Especially having the GUI easily extendable through Elisp. In addition to that:
- the amount of packages that integrate deeply with Emacs,
- documentation and code being visible from within the Emacs help pages. Extensible and org-mode Org-mode. Extensibility. Packages elisp. It's human-readable. No dialog boxes. Everything as text. Configurable. Simple ideas behind it. Community. Fully integrated interface for interacting with text applications, massive historical momentum, Org Extensibility and how customizable it is. Also the fact that Emacs is essentially a Lisp machine. Extensibility and changing its behavior at run-time Flexibility, speed, power, upgradability - extensibility
- free software Extensibility, GUI slate Community, and being a GUI interface to Unix tools It's a text-mode Lisp VM. An IDE for all platforms. Flexibility and scriptable. The built in documentation makes it easy to get started extending it. Feels sort of like getting started on the web and having an existing model to work in that you can wire little scripts for and see immediate results Ability to integrate different parts of my day/workflows and keep writing text largely consistent. For example being able to seamlessly jump from writing an email to making notes with org mode or planning tasks with org-capture. The extensibility and tight integration of many features. My go-to example in this regard is my workflow upon receiving an email with something I want to do later. I open the email with mu4e, use a capture template to prepend the email to my org-mode todo list or agenda, and am back to whatever I was doing within a few keystrokes. Its customizability and the flexibility that comes with it. I can use it for journaling and agenda management (with useful packages for everything from publishing blog posts to recipe collection) and for programming in many different languages. While there are other, better IDEs for specific programming languages, I've been able to get to good-enough with Emacs pretty easily.
It is open source and long-lasting. I do not have concerns about the editor losing support or, especially with writing, using file formats that will go out of date.
Org mode. This is a fantastic tool for so many things. It's easier to change and extend, any feature that I'd like to customize is defined in emacs lisp that can be redefined and tested easily elisp and flexibility Extensibility, and ease of use once learned I think the greatest strength of Emacs is its extensibility. The design of the application and its inherent "modularity" are what make the ecosystem flourish. That and being an entirely keyboard-driven editor which is ubiquitously available is fantastic. No nonsense by choice detailed editing commands (e.g. swapping words, rectangle edit) Extensibility and providing a unified interface to many tools. Extensibility, Org-mode, Magit, LSP That you can use it not only as a text editor Org Mode and Literate Programming, Major Modes extensibility, making an editor completely my own. extensibility, there's a command/package for everything I need & then more
portable Easy to adapt to my workflow The extensibility and multiple packages also lisp is pretty cool. The ability to customize everything, there are a lot of packages to use. evil-mode, org-mode, magit Extensibility and community packages Customisations. Org. Pdf-tools. Mu4e. Eglot. It's close to a Lisp machine lisp, packages Community, Extensibility, Multi-Platform, works in terminal RMS being controversial. It's customizability Consistency, speed, memory usage, extensibility ELISP, Package management (melpa specifically), availability for different platforms Core API, Extensibility via Lisp, package availability—in summary, a great design. Even with all its power, it can still be run in a terminal through ssh Extensibility and keybinding for everything Flexibility and customizability Extensibility, discoverability and the self-hosted development environment. code design and editing extensive and reasonably good documentation Rich text support extensibility and community! Extensibility and being able to edit anything within emacs from itself. The reply/smalltalk like nature of it. Keyboard binding It's an operating system so it can does everything. The sole limit is the imagination. Powerful functions window/buffers over 1200baud modem. Emacs scales, week machine toss out LSP and big configs. - Freedom
- One software to rule them all / Integration speed. Connection to repl Extensibility, packages, community Extensibility, documentation, packages. It can do anything with enough tweaking ELisp, libre source, cross-platform Discoverability, programmability, free Emacs is extremely customizable, and relatively simply so. Complete control and extensibility. One editor to do everything I want to do in terms of programming Reliability, customization, range of use cases Extensibility, Plugin ecosystem, Resource efficiency (compared to electron) it can be molded in anything a user needs. Also, the basic keybindings are sane and have been adopted as defaults for most unix terminals. Some of the concepts, like a searchable kill ring are still unique Extensibility, open-source, org-mode community and it's fun to use Org mode, control over layout, self-describing packages, community and extensibility Extensibility and flexibility Extensibility (lsp/eglot) one ide to support many different languages with minimum configurations (melpa), while having the same core editor experiences Extensibility, Tweaking I love using org-mode for journal and org-mode + org babel for creating executable documentation. Transparency and robust Elisp, org-mode org-mode ;-) Customizability, Programmability, Graphical User Interface Support Extensibility, Community Whatever piece of Elisp I write has the same importance of core Emacs features. No one depends on an API. Documentation and Extensibility, which work hand in hand to make Emacs an inviting system for users to explore. Discoverable, self-documenting. Provides a great sysadmin environment over SSH. It's self-contained so it is stable in the face of tech fashion changes. Capability "out of the box" without the need for heavy customisation. Extensibility and built-in features Its unparalleled extensibility. Emacs Lisp isn't a great programming language, but it's an excellent configuration language; the advice library alone is a big win over its competitors (VimL, Lua, or any combination of static toml/json/etc configuration files), in that it enables me to rapidly iterate in my half-baked ideas without boilerplate; which is priceless when you're tinkering with so large and complex a system.
Although Emacs' keystone packages (like org and magit) are a big plus, they are not what attracted me to Emacs in the first place. Extensibility and discoverability. M-x apropos RET gets me what i need 4/5 times. Help functions are really cool, being able to find new functionality and remembering keybinds, looking at variables and the source of functions helps a lot with understanding and personalising emacs Configurabilty Longevity, license, self-documentation It's free and has great support of Clojure elisp and hightly extensibility packages The package ecosystem: Org Mode, Magit, Evil. Also the extensibility that makes it possible for these packages to be so great. extensibility and flexibility -- the fact that I can create a macro, edit that macro if necessary and extend the environment to meet my needs always amazes me. Org mode, global search, capture, tags and tables are amazing for zettelkasten like notetaking, research systems. Community, Doom Emacs, Packages, after all this time it works better than the alternatives and it's so configurable. Community, 40+ year existence Longevity due to it's ability to adapt to latest languages and tools or in many cases introduce unique and superior tools (org mode, git magit). Extensibility, customize options Its an Lisp machine that provides an integrated computing experience It's extensibility is both it's greatest strength and greatest weakness. It can do anything, but I'm not sure if it does any of them extremely well, tbh. For me, it comes down to a combination of the longevity of the platform and the deeply embedded extensibility model.
I started using Emacs on an HP workstation in the mid-90's to write Common Lisp code. In the intervening time, it's taken me through a wide range of host platforms, work environments, and programming languages/styles. There are very few other tools that come remotely close to this degree of almost universal applicability over a period of decades. What this does is increase the value of learning Emacs - I can invest time in learning or customizing Emacs with a degree of confidence that I'll be able to reuse that work over a longer period of time.
The other noteworthy aspect of Emacs is how deeply the extensibility model is baked into the environment. This provides an extreme degree of ability to add whatever customizations you might need to do a job. Of course, a deep extensibility model isn't worth much if it's so difficult to use that the potential rewards are outweighed by the costs of implementing a customization. Here again, Emacs shines. It's trivially easy to get started with small customizations and work your way to more and more complicated scenarios as you need them. In my opinion, this is due to a combination of extensive investment in documentation, careful API design, and an open source model that enables putting the entire source of the tool at a developer's fingertips. There is essentially no other tool in modern use that comes close. elisp, packages, org-mode, calc Community, and evil keybindings for those coming from vim Extensibility, uniform interface for different domains, decades of knowledge crystallized in emacs and packages. Packages that are really Lisp programs that can provide a consistent interface across many different uses and easily share data between each other - extensibility
- its many packages Extensibility. Light weight. Fast. the mesh of data (text) and code (elisp) - almost like reflective programming, its extensibility Trustworthiness: it has lasted a long time, and I can rely upon it to last well into the future. configurability, emacs as a lisp platform with a text editor strapped on Org-mode export
Packages Very extensible. I can make the Emacs experience completely my own to fit with my workflow, and that is something I miss in other editors. Have not tried Vim which I assume offers a similar experience. My config at work and at home make Emacs very very different tools Extensibility, Community, and Freedom. I'm somewhat familiar with it. elisp
magit Adaptability and long-term usability Org mode, Org-roam, literate programming, Magit, great VIM keyboard support Being able to do everything in one place, there are a lot of non-obvious benefits from being able to write software, run software, inspect the output of software, and write about software all in the same program. Being able turn program output into figures and format them in LaTeX without mentally switching context or keybindings is simply better than anything else that exists today. Combined with org-mode, I spend significantly less time thinking about tasks that are unrelated to what I actually want to be working on. Portability. Extensibility. Longevity. Its community - I can almost always find someone else who has already figured out what I want to do, or at least shared the pieces I can put together Extensibility, keybindings (vanilla ones and the ability to have whatever keybinds you want such as evil-mode), self-documentation, ease-of-use (steep learning curve but once learned you're set) I use for writing prose, because I'm a human science research. I like the text processor capabilities. Its programmability and resulting customizability, due to its open source nature. It means that, in principle at least, I can tweak it however I want. In practice it also means I benefit from others' packages and extensions. org mode, speed, ubiquity Fast and modifiable.
Most importantly I can exist within a single ecosystem, running browser, music, repl, directory, and editor without the mental whiplash of exiting my workspace. Extensibility. built-in documentation. It runs in both console and GUI. It is still actively being developed. - Ability to extend its functionality in Elisp;
- Handle huge text files; Extensibility with elisp.
Changing live the runtime without restarts.
Modes for everything. Email, news, irc, github, code, etc etc -> no need to change editors -> one editor for everything Its unwavering dedication to its niche, which attracts like minded and capable people It makes complex actions easy to do. I love its macros.
I can do everything inside it - no context switching needed. Packages / org-mode / tramp I am familiar with it, it will not change (much), so now I know it, I can use it 'forever more'.
I can use it for any language, and the editor is still th same (mostly). lisp; community extensibility, community, customizability, the usual keywords. Extensibility, magit, org-mode 확장성 Its extensibility and modifiability That users can extend Emacs with code that is just as privileged and powerful as the Lisp code that Emacs itself is mostly written in.
Other software that considers itself extensible usually have an intentionally limited extension API or only allows scripts to be run in a sandbox / on specific occasions. extending emacs has such a quick developer turnaround loop, this makes trying things for text editing easy and fun
developing uis in emacs is far more pleasant than any other environment (tabulatedlist-mode, transient, etc). The extensibility and the wealth of packages. Able to use vim keybinds lol The greatest strength is how flexible and malleable it is to cater to all of my needs. configurable Free forever and its extensibility I don't need a mouse
I can make it do whatever I want it's transparent, easy to modify, it's free software Long term stability extensibility and customization Simple C-based core
Elisp That it can be extended by a decent programming language and that it has a good underlying design. The openness of the code to modification. Not in the open-source sense (although that's an important prerequisite), but in the ability to replace or augment any behaviour that annoys you. This not only includes adding packages, but also hooks (lots of them), advising or replacing functions, or mucking with internal variables. Quickness via keyboard shortcuts Being the closest to a Lisp Machine that I'll ever use. Keybinds Infinite extensibility/customisability, open source, ELisp I expect to get a great deal of control of my work if I put in the time to learn the now-slightly-odd Emacs way to do ... whatever. - solves problems I didn't even know I was having
- one stop shop for everything
- going above and beyond in usability for day-to-day work
- any task can be easily automated Multi Platform, Packages / Modes Longevity, Community, Extensibility Command discoverability
Buffers and windows Batteries included. Do not have to hunt around for 90% of basic functionality and language support. Org mode for note taking and writing. Extreme customizability once you understand a little bit of elisp and discover how to identify what to change. Ability to add functions of various complexity right in the config, rapid hackability What is possible is only limited by one's imagination. Being an reasonable easy to extend framework. Lots of packages, starter kit like doom takes minimal effort to setup a full IDE experience. Runs on terminal. Org mode; configuration rectangular operations, integration with GDB, keyboard macros, dired, shell Flexibility. Extensibility through a full programming language Ubiquitous, can run in a terminal yet allow sophisticated editing. Extensibility and modifying default behavior without maintaining a fork Key bindings (customizable). Configurability, packages environment, programmability, Org-mode Native GUI
Modularity Extensibility, ecosystem and the greatest: I can rewrite the editor at runtime Packages, customization, org mode. Faster than VS Code (electron gtfo), lsp-mode works more reliably with clangd, custom keybindings are easy, ALT-X GIVES ME EVERY COMMAND WITH SEARCH <<- this. Stability, it's on every platform. - Lightweight
- Extensibility * extensibility
* elisp plugins and easy script extensibility, rich text in GUI (compared to vim) Extensibility and built in documentation for functions and variables The feeling that all pieces of the text process can be integrated programmatically and the ease of automation that results from this. The insights of how to leverage this from the great emacs community adds a lot to the beauty of this. It's incredibly extensible and can be made to do anything. Even though I don't currently use Emacs for checking my email or keeping my calendar I want to and know that I can. Easily extensible, transparent, well documented editor codebase Text editing capabilities
Extensibility Emacs's community and extensibility combine to provide a work environment that is prepared for most any problem. No matter what (text-based) tasks my work or personal life throws at me, I know that Emacs will provide a top-notch experience that won't get in my way. The extensibility, and community. text editing. The ability to easily inspect and modify all parts of the system allows me to implement features and workflows which I wouldn't even dream about when using an another computing environment. Most improvements to any part of Emacs propagate through the entire system. Longevity, capability as a UI to the underlying OS Lisp-backed, interactivity, self-documenting nature I believe I mainly got used to it, there are some particular scenarios where vs code works better, but I don't have magit nor doomemacs keybinding there... Extensibility and fantastic ecosystem GNU, opensource, cross platform, no bloat, no nonsense, extensible, packages, Run-time configuration, self-documentation, explorability, large community. Customizability, keyboard based interface Extensibility, lots of packages: I can use the same editor for a lot of different tasks. And it has org.mode. Coolness, Expandability, Loveability! Ease of extensibility
Free to use and modify without being backed by a profit-driven organisation Amazing community tools like org-mode and magit. Keyboard Macros, extensibility Modelessness Emacs Lisp, freedom, Lisp, running on both the CLI and the GUI, Lisp and also Lisp. Emacs makes a great "overlay system" to almost any other operating system--or even work between different operating systems and environments (e.g., TRAMP). I use it for a variety of tasks related to everyday file handling, writing, note-taking, coding, sysadmin, and other work. These very different contexts are unified in the system that is Emacs. I credit it with being able to handle a lot more complexity in my workflow, to change contexts easily and with less cognitive load related to "switching costs"--than any other tool on my computer. This is kind of a meta-level answer, but I believe it explains Emacs value better than any particular package, tool or function it provides. Ease of making custom integrations It’s everywhere and it works. And org mode. Definitely org-mode! Being mostly written in elisp, configurability. Text-editing extensible, sustainable Lisp! It's much more than a tool as it is designed to be hacked, so it's a hacking school itself The fact that Emacs follows the one true interactive programming paradigm: An interpreter that can be interacted with via code AND input device event hooks. IE easy and pervasive extensibility. Hacking Lisp. obviously. :-D Strong community-driven package ecosystem; org-mode Elisp extensibility. Community. performance and easily extendable The built in documentation Org-mode, extensibility It's sooooo fast, and versatile Full customizability - the fact that the entire editor has an "API" that can be programmed against using a real programming language is unique and great. It's also mature, which means there are many packages, tutorials, and others in the community building useful things on/in emacs. Org mode, text and code editing. magit
package ecosystem Editor that can edit itself. extensibility, scope and depth (it does everything and everything works together - everything is a buffer), part of the GNU project - free as in freedom Evil Mode and Lisp It's textual interface leads to unexpected but amazing workflows that just don't exist in other editors.
Take wgrep for example. You can do a search for a string, get a list of results then edit thoes results as though they were a normal string buffer with all of the other emacs settings, macros exiting packages is just amazing and not many people outside of emacs appreciate that this is possible.
The transient workflow that magit uses is another example of this. Unexpected but great efficient interface for working with git.
The final thing that is great about emacs is that everything is a command from moving the point around, insert text, all the way up to advanced magit functions. This means I can take them and automate and tweak settings to perfect my workflow. command mini buffer Extensibility, but also a curated out-of-the-box experience when using one of the batteries-ready distributions (currently using Doom). Very customizable. There are a lot of packages available. Can run as a daemon. and yes there is org mode. Which I absolutely love. Flexibility, ease of extension, it's fun! Highly customizable by Elisp The extent of functionality: so many things have already been thought of by someone and can be made to work.
The extensibility: if it isn't there, you can put it in! extensibility, fantastic 3rd party package quality (magit, eglot, etc.), free software Customisability, High quality packages, Integration of various packages - Unix philosophy
- Configurability Being a base layer for building an editing experience, allowing for deep customization if things most editors don't let you touch (e.g. customizing completing-read, completion-at-point-function, etc) lite Extensibility and open source. Everything can be tweaked with code. Extensibility and/or customizability It sticks with you for life, so you can build a tower of knowledge on top of it. Everything-is-a-buffer paradigm. Although not as great as Acme's (/ Plan 9's) "_every_ text is _actionable_" paradigm, buffer being the de facto data structure for everything makes Emacs an attractive option. Community and Extensibility keeping my fingers on the keys, extensibility, theming Extendability and way how it integrates different workflows into unified way. ability to use the same editor in the terminal and gui extensibility, magit, org-mode Customizable, Extendable, Keyboard-focused, great packages Extensibility and how everything I do is in a buffer Extensibility. I love the hyper-personalization to make the editor exactly mine. The fact that is almost a virtual lisp machine and uses the lisp language is very helpful. Also the fact that it is so old has stood the test of time so far is actually very reassuring. Have a good chance of the editor being around for a while longer and grow with your skill set in it.
Good community of people who do very niche stuff at times but very helpful also is a massive plus.
You can do so much with it, including turning it into a window manager and that is great. the extensibility, the longevity Still learning, can't tell, but extensibility is surely great. Full leyboard navigation is also lovely. I don't like T-based editors like nvim/helix, while VS Code does some funny stuff to my laptop. We don't talk about JetBrains here * Efficient keyboard-based navigation
* Efficient use of screen real estate
* Extensibility Reusable and composable paradigms, such as the minibuffer and completion, allow you to really take control of emacs' behaviour. Part of the joy of Emacs is that popular community packages tend to adhere well to these established paradigms, such that they interoperate with little fuss. Customizing a certain movement or completion behaviour once upgrades it all over emacs. Extensibility, support for editing basically everything The possibility of being as basic or as powerful as you need/want both at the same time. Extensibility, some amazing packages, and the fact that it's free software and not controlled by a corporate like Microsoft. I'm at the stage of wanting "forever software" and Emacs is one of those. It makes people excited about working on it. While it may not be the most efficient way to do things at the start, I believe that it is a positive on the long run. Terminal support and emacsclient. Elisp, packages, community, been there since eternity Cross platform, including command line. There is a mode for every language. I LOVE org mode. Open source, great packages, flexibility, lisp configuration language Readable, structured customization of basic editing, and the well-developed modes (C, org). Extensibility in Emacs Lisp and Org mode Emacs is extremely reliable and fully programmable, still the best and most powerful editor in the world. Amazing, after so many years! There are so many features and packages that if I find I need to perform a very specific task I can often find a function that will do the job with M-x or doing an internet search for a package. ORG! I guess the extensibility enables All the great packages I use, but I don't write anything myself (yet?) - transparent editing and dired access
- GUI or terminal editing both work
- extensibility and user community While it comes with a million features, it doesn't feel cluttered and doesn't shove functionality into your face that you rarely or never use. You can use as little or much of Emacs as you want. I feel that other editors often are pretty overwhelming. I also like that many of the packages are of high quality where it's been more hit or miss when installing plugins in other editors. Its versatility. Its help in the commands that help you to learn it Package ecosystem and maturity How much the Emacs care about backward compatibility. Plus, how powerful and simple the system to extend Emacs is. Extensible with a variety of packages extensibility and bindings to the underlying operating system Elisp. I really enjoy the level of extensibility and customization that is possible. Fuzzy module bounds; can integrate any part into another part with a few lines of code.
Org-mode. Extensibility, Mode concept, Generality and Introspection ORG mode, Infinite extensibility Flexibility, adaptability, extensibility, feature-completeness, works well in GUI and TUI even over long-distance ssh, no need to take hands off the keyboard. Extensibility, hackability, configurability Large community with a package for everything Community of contributors Its modularity, its adaptability and its community. When it does work, it works perfectly. Extensibility and Lisp The keybindings have not changed sufficiently to drive me elsewhere. It gets out of my way and lets me work. I love all the modes and packages available, especially tramp. Orgmode, dired, magit - ecosystem: mainly Org-mode was what made me began using Emacs, but there are so many other great packages...
- extensibility: but also I was using Vim before which is pretty limited, so Emacs' extensibility was a huge attractive and still is. But Elisp is very problematic (performance, async/concurrency, safety, ...), just as C.
- self documenting
- free software: should be GNU AGPL instead though
- client-server: although it is not proper because of issues for remote connections
- keyboard-driven: should actually be interface agnostic as to future-proof and for better accessibility org mode, dired That despite containing everything including the kitchen sink, it still feels mostly elegant and easy to extend. Flexibility and extensibility. Emacs mostly stays out of my way until I need it, when I can whip up a macro or some elisp to solve a problem quickly - Ability to spawn subprocesses very efficiently
- Low memory consumption
- Really good syntactic editing packages like paredit/smartparens that work for languages other than lisp not found in any other editor
- dir/file/buffer local variables
- Hierarchical keymaps Magit, org-mode, malleability is nice well- and self-documented; active community; extensible; it becomes natural to want to do everything in emacs Key bindings, runs everywhere Transparency: You can go right from wondering "how does this work" to the keybinds, to the function documentation, to the source code. The whole system is amazingly inspectable.
Malleable: You can get an idea for how things ought to work, and make them work that way immediately. In 99% of cases, there's no need for code-compile-test cycles, it happens instantly. works everywhere, huge amount of packages, very flexible Text editing, extensibility, works in a terminal. Batteries included language, bonus points for it being a lisp variant Packages, extensibility. It can be adapted for any purpose -- and someone has already created a package for that It's a good platform for writing code, both for itself and to develop other things. The text-based everything makes things easy to manipulate as compared to most other things. Fully open source and extensible, as well as a great community and ecosystem of packages. Doom Emacs extensibility & malleability Emacs Lisp is highly extensible and can do anything that the OS can do. The community and the extensibility The fact that you can customize anything. Being a "real" free software. Having a philosophy behind which so far has outlasted any other. Lisp machine, extensibility, free/libre software, self-documented Multiple Windows, keybindings, elisp customizability, documentation magit, org mode, calc
It has some very good features, above are the true killer features. Having a true programming language for "configuration" is a big plus as well. It is keyboard based, no need for a "mouse hand". And many more. To summarize: it is just great Org mode and Lisp support are its hand down greatest strengths. I use Org extensively at work for all note-taking and prose writing. Professionally I use Emacs for TypeScript (via lsp-mode) and Python (elpy) and find it's quite good. I spend most of my personal programming time in Racket (racket-mode) and Common Lisp (Sly) which Emacs is fantastic for. Self-documenting and extensible Keyboard-driven, org-mode, magit Org Magit, a proper extension language keyboard shortcuts, elisp, GPL Being a LISP machine, great ability to adapt to everyone need. Free (as Free Software). Configurability, elisp, org mode, magit Lisp machine concept High quality X Windows support and mature text editing features. It's ability to integrate with other systems on the system. This is usually done with some package being able to communicate with external libraries or processes. Extreme adaptability and a strong community. Of course not to forget org-mode and org-roam which are a killer features. Emacs (combined with a community distro like Doom) does a reliably good-enough job at almost everything I have managed to throw at it, and the few inadequacies I've run into have been easy to fix. I'd attribute that to its unique combination of malleability, self-documentation, large and high-quality user community, and the maturity of the project. Extensibility, and can be fully tweak as needed. easy customization. Everything is doable after some work. Strong community support, many well-maintained packages, distros Predictability Customization, fully customizable by code, extensible, every problem has a solution. Overall it feels consistent The simplicity and extensibility Extremely customizable with Elisp. extensible programming environment The fact it's a lisp machine. Any and all features can be stripped out, replaced, expanded etc. Customizable, and lighter-weight compared to full blown IDE's (pycharm, intellij, etc.) Buffer management and moving frames, along with the perspective package having an easy way to manage file scope for specific projects or repos. Extensibility and a lot of packages Stability, rich package system Being able to modify any functionality directly through it's global scope and how extensible it is through elisp. Extensibility, how old it is and the fact that it's free software. Programmability, interactivity and Lisp Cursor movement without lifting my hands from the keyboard, extensibility Builtin packages Help system with finding functions, keybinds, documentation It's extremely powerful and flexible, has stood the test of time, and has a good chance of still being maintained in 5 years. Flexibility, available packages elisp because it makes it extensible and interactive. 1. Unique GUI-TUI compatible "all-is-text" UI paradigm
2. Complete customizability to implement smart UI features on top of "just text"
3. Can integrate multiple use-cases (email, file browser, coding, ...) coherently
4. A Lisp as an extension language That it can do everything you want it to, and it runs everywhere as well, on about any hardware fully customize The packages, the customizability, the community it's more of an operating environment than a text editor. ESS Customization, extensibility, packages, org-mode. Configurability with Lisp Good editing features. Good built in tutorial and help. Keybindings work well if you learn them early and get them into muscle memory. It can be customized or modified to meet any particular demand made of it. Extensibility (LSP, tramp,...) Extensibility and learnability Customizing the editor by writing programs. The fact that everything is a text. Extensibility and introspect-ability You can make it do anything you want; complete freedom For me, it's all about how you can make emacs your own. Built-in documentation, integrated environment (code, org-mode, calc, shell) built on lisp Extensibility. It can do or be anything you want it to. Easily hackable The package ecosystem. Elisp is nice, but for the most part I haven't had a need to write any complex packages myself, since almost anything I could need already exists.
Being able to write the few missing parts is also a big strength. Extendability and customization. And stability in some form. I won't have to switch editors anytime soon can be easily extended Being able to reach in to any internal and read/modify/understand how it works. Package ecosystem, the full functionality of org mode Extension and long term usage It can handle a wide breadth of languages, and the keybindings are complete muscle memory at this point. Elisp, extensibility, large ecosystem of plugins existing packages & ability to modify the interface / text however you see fit One text editing experience across many different tasks, and Magit It can be your OS if you want it to be. having easy to use modes for doing almost anything Programmability and self-contained documentation. org-mode, org-agenda and custom functions to automate life - Knowing that Emacs is not a fad, i.e. it's worth investing time to learn
- Packages are available for nearly everything extensibility, lisp machine Unmatched extensibility, very active community that causes Emacs to be constantly developed further. Extensibility, hackability, configurability, and a couple excellent packages (org, magit, projectile) Flexibility, power, functionality, extensibility org-mode, better than Vim IDE features but still good Vi-style key bindings GUI Extendability, longegevity artist mode It's cool. Extensibilty. Customizability. community especially the ones maintaining large distributions and packages such as doom-emacs / magit / org-mode and major modes Extensibility, minimalist look and Magit Extensibility, LISP. Extensibility/customizability, elisp, reasonable foundation, can do so much from within it, still can run it on terminal. As Protesilaos Stavrou has articulated so well, it's the unique gestalt of Emacs-as-environment that makes it so powerful. It truly embodies the technological and social potential of Free Software. Stability
Quality Packages from community Self documenting nature. Magit and org. Extensibility, configuration, TRAMP Magit and other great packages. Infinite customizability. open source and free software, extensibilities Packages and built in features like gdb client Evil mode and org mode The melpa package ecosystem. Features and packages are often very easy to start using and understand, because they are made and refined by a community that cares about it being simple to use. Deep extensibility. It is great at manipulating text. It offers tools that are just not available or abandoned from other editors- such as narrow mode and rectangular kill & yank. The ability to do just about everything from the terminal means my hands never leave to the keyboard and loans itself creating quick one-off macros. - timelessness: editors come and go but emacs & (neo)vim stay around
- libre software: it does not spy on me
- extensible, especially since package.el the history, the buffer concept and the community. 40+ years of development and solid package development community Extensibility through external packages Extensibility, and that it's FOSS. - we can program Emacs the way we want
- documentation is included
- Emacs configuration, functions, etc can be inspected Extreme flexibility + Lisp keyboard navigation, predictability, customization. Modularity, flexibility, and making your tool suit your trade. Extensibility through elisp. Powerful packages such as CIDER. Useful package ecosystem, extensibility Support for code placeholders Its extensible, and it is pretty discoverable Crazy extensibility and adaptability to any workflow. Emacs embodies the idea that text is universal and software must be free. Also, I use org-mode every day for note taking. Extensibility. Stability. The self-documenting nature of Emacs, elisp extensibility, and the community Adaptability, extensibility Lisp! Modularity! Plugin Quality, Org Mode, workspaces, magit, execution of commands Extensibility, Flexibility, and long term support. It's a lifetime editor Spacemacs default packages+ clojure layer dynamic extensibility, customizability (and *layered* customizability), unified interface to many different tasks, built-in documentation, buffers (in my view much more powerful than the ubiquitous tabs), ... Keyboard centric workflow, no UI annoyance, Libre Extensibility, moldability The fact that most of it is written in Lisp, even if Elisp is not the greatest Lisp out there. There are features I'd like to see, such as file-local symbols or reader macros — here's some stuff I once wrote: https://github.com/mishoo/elisp-reader.el Portability, extensibility & malleability Elisp, Everything is a buffer (orthogonality), you can add any functionality very easily (that is impossible even to imagine elsewhere), keyboard bindings and their extensibility Integration with Unix command line environment. The extensibility of emacs where the core is written in elisp and can be extended in any way I guess and that it stood the test of time open source, works in terminal and gui, extensible, configurable Endless extensibility, Org mode, active and creative community Extensibility, Org Mode, Flexibility, Elisp configuration Extensibility, programmability (automation of common tasks), org-mode ecosystem, magit Its community and extensibility customizable It's powerful and flexible. It provides a consistent, stable framework for working with text. It has exemplary documentation instantly available without having to go online or having use ghastly web interfaces. It evolves very slowly and carefully (usually). Keystrokes and methods to keystrokes and family It fits my needs through many available packages and its extensibility Flexibility and user empowerment Keyboard focused, no need for mouse. No Gui necessary. Extensibility. Extensibility, visibility of current state. source code available, good documentation, elisp, and ongoing improvement of elisp Its extensibility and how customisable it is (E)lisp Ability to integrate all tools in on (email, calculator, shell, git, etc) Extensibility and integrating everything together. Packages that fundamentally change your workflow and how the program is used — transient, magit, org, notmuch, corfu, consult, which-key Extensibility. It feels like a tool that I can adapt to me, instead of having myself adapt to it. Customization, extensibility Amazing packages, programmability, LISP, text based interface Existentiabillity Vast libraries, highly configurable, batchable in addition to primary interactive usage, and the fact that my brain has become wired around it over the decades. lisp, extensibility, and the package ecosystem (you can pry magit from my cold, dead hands) Configurability, and the resulting community focus on work flow and efficiency Freedom and extensibility - Plain text
- Faces customization (font, color, size).
- org-mode utilities: Todo, Agenda, Calfw-calendar, internal links 1. Extensibility and a good package system (after Melpa came into being)
2. Large userbase of developers
3. Integration with Unix like OSes Org Mode, Magit, LSP, Vim Easy extensibility, convenient introspection (going from "how does that work?" to reading the relevant source code takes a couple of seconds) It's run on every system I've wanted to use for the last 30 years. self-documenting The extensibility via Emacs Lisp (including live evaluation of code); Emacs is stable but still evolving; Emacs is lightweight compared to more "modern" solutions like VS Code; The community supporting the various packages smart editor Extensibility through scripting (in this case ELISP)
Keybindings assigned to custom functions (global-set-key -> defun) and special modes
Ability to use it within a terminal
Cross platform (ease of installation through package manager)
Opensource GPL Emacs is hard to learn but in fact really simple when we get used to. I always discover new features. Emacs answers to 90% of my needs. Emacs' extensibility and full customizability. You can bend the editor to your whims, and turn it into anything you like, to maximize your productivity (at the cost of configuration timr). I can customize it and make it whatever I want. Extensibility, I like that I can get Emacs to do what I want, the way I want. Packages for any functionality you can imagine, and extensibility for the rare thing that's absent libre, extensible, dynamic, explorable, stable.
compilation mode, rgrep, completion frameworks, Dired, Magit… Solid foundation of extensibility, which proliferated into a bunch of helpful packages.
If you want something, there is a way to get there. * GNU/FSF
* magit Freedom and control overall consistency over time, availability across platforms, ability to accommodate a wide range of usage patterns (with notable issues) AucTeX Extensibility. Lisp environment. Its extensibility cannot be matched. The experience of using Emacs is also quite cohesive. Once you've used the editor for a long enough period, you gain a sense of why certain design choices are made. Most frequently because they are the most convenient means of achieving some end. So when you finally crest the learning curve that comes with emacs-lisp, you'll likely contribute something that is inline with Emacs' ethos. Of course there are some hacky behemoth packages still heavily used and maintained today, but inertia for sub-optimal design is soon sapped when a better alternative is widely known. Its stability, longevity, extensibility, and introspection capabilities. That it's a programming environment that happens to manifest as an editor. elisp gnu-free Backward compatible is taken very seriously. extensiblity, elisp, rich feature a creative terrain of people creating something cool together, where we get to own the project. also i like that we can sculpt it how we want it with lisp. even though i have barely fiddled through a bit of lisp, i can copy/paste it into my init file and i more or less get what is going on. You can do EVERYTHING in it Good text rending, neat UI, very extensible Customizability and free and opensource You can make it whatever you want it to be, everything and anything can be turned on and off Emacs is free software at its best: I can understand and customize everything! And there is a great community around! Customization, open community, easy extensibility, and the plethora of historical packages. 1. It works;
2. I have muscle memory;
3. While I rarely take advantage of it, the extensibility makes it incredibly versatile. adaptability trust a lot of capabilities Its extensibility and built-in features. I can write, run, and compile C code and even read along with a book in doc-view-mode all without leaving emacs. Eww is an underrated browser and loads images very well in GUI emacs. Extensibility for me is Emacs' greatest strength, also the awesome community. Extensibility, Lisp, Community SLIME and extensibility Extendability, keyboard only interface Magit
The fact that everything is just text buffers that you can use your existing editing commands on. Open source, extensibility, community Emacs is great because it's simple and lightweight enough that it doesn't feel bloated (looking at you VSCode) yet is complex enough to do all the tasks I need (lsp-mode, org-mode, etc.). I also appreciate that it uses a real functional programming language (Lisp) for configuration (looking at you Vim). Extensibility -- Elisp
All sorts of community and packages
``Killer Apps'' -- Org, Magit, etc.
Evil -- You could use Vim in Emacs so...... Doing stuff with keyboard instead of mouse, and configurability. Elisp environment Stability coupled with almost infinite extensibility Hackability based on Lisp extensibility. Keybindings, org mode That it's an Elisp execution machine. Full lisp environment everything is a buffer. Very discoverable. Good documentation. Some great packages like Magit, org-mode and CIDER extensibility is my #1, I have no idea how many times a day I write a macro to transform text into some other format. pretty close is to that is openness and freedom Same reason it’s the only 20th century codebase with chance to remain in use by the 100th, but it’ll take me an essay to explain. It’s a combination of factors, not any one. Wide ecosystem and extensibility. programmability + community = good packages Community, packages, extensibility, free software The promise of being able to create a minimal set up that works for many languages Being able to simply and easily compose multiple, complex packages together to create custom workflows Extensibility, Key bindings and its customizability. The level of customization in combination with years of written packages extensibility, programmability Org mode
Discoverable key bindings The extensibility where I can, even though most of the time I haven't, further customize it towards my needs. Extensibility, uniform UI for different tasks Easily looking up function definitions, variables, org-mode. Extensibility, Lisp-machine, well-integration with OS, self-documenting, text-oriented, stable Elisp is really easy to get a grasp of. I used vim for years but the config language just never clicked for me. The extensibility is also good and I like how easy it is to write my own functions if I need them. Its extensibility/flexibility. It can do practically anything. And elisp is a very accessible language. The documentation and community are very helpful and accessible to newcomers. Customization, elisp advanced, extensible, customizable, self-documenting Can survive with minimal tweaking and defaults. Runtime for to create TUIs Principles of the GNU project, extensibility, lisp, ecosystem Unified interface, easily extensible, excellent community. Simplicity and complexity at once Open, dynamic, history Customizability, extendability Freedom, extensibility, ubiquity. I know that any investments I make will be repaid. For something as foundational as what I type into most of the day, I need to know that it can't be bought or reprioritized by a commercial entity. Efficient keybindings that I can use for a wide variety of text adjacent tasks Its extensibility and the simplicity of its programming model Magit
Its community of active users. Gpl, packages, extensibility You add the functions you need and can change how they work. Packages, magit and org mode. Great ecosystem and doom gives great defaults Community, FOSS Anything can be done with the keyboard, and the various operations are very uniform. Its customizability/extensibility Extensibility, Querying functions,vats,state. Extensibility, consistency, simplicity, Lisp Extensibility, without a doubt. Extensibility. Lisp Machine. The extensibility, package ecosystem, and text manipulation/interfacing. Org-mode, infinite extensibility I can do a lot of things with just a few keyboard strokes. customizability and packages that can fully change behaviour Extensibility, eco system Extensibility and internal documentation I can configure it to do much of what I want through readily available packages. Portable, long lasting, actively maintained Programmability, cross platform Everything that comes built in, like the image viewer, dired, etc. Customizability range of packages tons of features Being FOSS. Being customizable and extensible. Great package ecosystem. It doesn't change. I can use a package that hasn't been updated in 10 years and it works. Free software, lisp for configuration and extensions. magit and org-mode M-x, C-h k, 'defun Speed, customisability, fewer distractions self-documentation, extensive documentation, extensibility, all the packages already written for it Extensibility, as well as specific behavior not present in other editors (non-destructive undo and keybindings for my case). It's model. That it is a core that an editor, arguably multiple editors, are built atop. A core upon which more things can be created. Extensibility, simplicity, large community, can do everything you need on a computer in emacs essentially. Emacs lisp, which leads to it's incredible extensibility. Extensibility and incredibly high quality packages Universality. You can use it for everything. Readline, Customization, History Terminal support It’s an inspiring example of composable design where packages can be combined and the user is in control of how the pieces fit together. User doesn’t have to re-learn basic computing functions to use functionality. This all stands in stark contrast to the dominant “app based” computing paradigm. org-mode, magit, meta packages for many modes, ediff Battle-hardened. It's as old as I am.
If you look, you can find anything for it. Whatever you find is adjustable with little effort. Everything can be configured via a homoiconic, repl-driven language Combined power of extensions on a custom local and remote IDE. Extensibility and built in help The community Configurability and capability Extensibility and customisation Structural navigation (in lisps) Lisp, community, introspection, there is lot of packages, power of extensibility, magit, dired and org-mode Introspection, keyboard navigation lisp interpreter + editor extensibility, customization & adaptability to the given terminal environment recording and replaying keyboard macros Extensibility and versitility. Extensibility and good packages. org-mode and the extensibility emacs provides as a framework. Extensibility and packages created by the comminity More options to configure it as wish, faster. Customization/Extensibility less heavy than others Org-mode and numerous other packages Everything is customizable I like org-mode especially!
Emacs' universal environment for editing and coding. Lisp Machine elisp extensibility, a miniature lisp machine. Keybinding! Keybiding! Keybinding! It’s flexibility allows for a large community of users to add, try out, and curate great solutions for nearly ever use case. Extensibility (elisp in general) and dynamic documentation. It's interface. User extensibility, customization, also being part of the free/libre community, Its flexibility and power Leveraging (arguably) one of the planet's largest package archives. Best development environment for Common Lisp and Clojure.
Text editing capabilities. The extensibility allows me to perform a whole range of tasks all within Emacs. I would hope editing text. Extensibility. Good integration with other tools both inside (org-mode) and outside of emacs (magit, bibtex stuff). Its extensibility and the use of a "proper" programming language, which is highly dynamic and interactive, yet relatively uniform and simple.
This allows Emacs packages to scale and go beyond just simple hacks. In the words of a blogger Tim Bradshaw: "All sufficiently large software systems end up being programming languages." Continuity in the community support of packages. In Atom and Sublime, I was frustrated that most packages had been started by people as a hobby and then abandoned. PlantUML in particular did not work in Sublime, but my peers would show how great it was in the new VS Code at the time. I saw that VS Code was mostly the market place and was afraid those would soon be abandoned too. I believe that the Emacs' community is more robust in that it is not just young adopters, but people that invested time in mastering Emacs for many years. You can quickly learn a Sublime Text and hit upon limitations, but after 3 years, I'm still learning new things that Emacs can do. That is not just because I'm on the master branch, there is plenty to discover that has been in Emacs for decades. Extensibility, modularity and community Text manipulation, minimal interface, portability, terminal interface, syntax highlighting powerful, consistent (many commercial packages keep changing stuff) Unparalleled mouse-free productivity, text editing, customisability. Freedom as a user. World-class code indentation and awesome flexibility. extensibility, lisp I like that I can run it in a GUI or terminal, and being able to have a terminal right next to my buffer, or a dired buffer open when I'm working on multiple files, etc Lisp. Lisp is magic. Customizability and extensibility -- it is very, very nice to have a general purpose tool that is able to cater to my specific needs and preferences.
Org-mode and related packages and features -- org-agenda, org-babel and source blocks, org-roam -- has completely transformed my workflow and conception of how to organize my personal projects and data. I use LaTeX a lot, and while the auctex package(s) and tools are great for editing .tex files, the ability to preview LaTeX fragments in org-mode, as well as have code blocks and tables, is remarkable. Also, the ability to have a (semi-)literate Emacs configuration in an org file, with links and notes, is incredibly useful.
Finally, the community is amazing. I have received help for about 80-90% of my queries, in some cases when I expected the problem to be too obscure to be remotely reproduced elsewhere. I have also borrowed the bulk of my configuration from the many brilliant members of the community out there, and have learned much more about the capabilities of this simple lisp interpreter. does everything lisp and lisp machine like design Extensibility, freedom, community. all these apps that live together and boost productivity orgmode
multiple copy / paste
commands working on 'selected region' It's extensibility, to turn it into an IDE for building your systems and applications. Openness extensibility, elisp, packages, keybindings, extensibility The text editor being tied as an interface to a programming language and interpretor.
From this, comes its customization.
As of today, I can say the community, as a nice fellowship, and as all what she brings to make this venerable editor attractive today with contributions and genious ideas on how to make use of it. The extensibility - both in the choice of Lisp and the API Emacs provides for controlling it no mouse Free software, community project, customizable, extensible, keyboard driven. Discoverability, consistency in ui and concepts, very customisable, fairly easy to understand Extensions Eliso extensibility Org-mode, extensibility, customisation and availability Extensibility of course, but also the introspectability and self-documenting nature. The package ecosystem these days is amazing. Extensi Commitment to free software, Extendability Extensibility through programmability It's a lisp interpretor with a giant suite of lisp programs. Extensibility as a TUI. elisp, package infrastructure, good documentation and help-functions 1. Philosophy: the desire to be supple enough to meet diverse user's needs. The recognition
that today's novice can grow into having an expert's needs.
2. Stewardship of maintainers.
I am constantly amazed at the level of sophistication and knowledge of the maintainters.
The discussion son the emacs-devel mailing list can seem tortuous and frustrating at times, but
I would ascribe that to the refractory nature of the topics.
3. The importance given to documentation. That it's all lisp Powerful extensibility.
GUI The editor is a text frontend to an interpreter. Everything good follows from that. customizability, broad range of plugins Plain text front end which does not scare people starting. Extensibility and text manipulation preservese rights of users, extensible Extensibility with a lisp flexible Flexibilty Great packages, community Highly configurable; portable "operating system" with a flexible GUI framework Ability to tweak everything with a tiny bit of elisp. The extensibility and package system is the greatest strength. I can reliably setup a new programming language environment and have it working with Emacs really quickly. I can include my preferred source control tools like magit and personal customisations without any extra work. For example I wrote a custom mode for a Smart Contract Language using lsp-mode and an existing language mode, in a few days and used it for work for 2+ years. * Never having to touch the mouse in any way.
* The ability to customize any feature for my current project or mindset on a whim.
* No UI, as much as possible. Show me the content I'm editing and nothing else.
* A good, extensible, set of keybindings with a bunch of features for editing of raw text Extensibility and lisp Self-documentation and extensibility Large amount of plugins, extensibility, text editing features, familiar environment on any platform Large multi-gigabyte text support. Ingrained key configuration. Ongoing growth. Extendability. No matter what I need done, there's a package for it, and I need to leave the editor less and less. I have known nothing else. I have also not found something that Emacs cannot do. The community and Org-mode. consistent structural editing across languages, self explanatory UX (show keybindings in menus, mouse-over, ..., C-h _whatever_ ) ability to override the behavior of any function Community and extensibility for sure Extensibility, multiple utilities are available in one interface (mail, news, calc). Clarity, simplicity and a rich ecosystem of packages Emacs is older than I am and will likely outlive me. Investing in emacs really feels like investing in something for life, rather than changing editor every few years. Community, org-mode, extensibility wealth of packages and configurability It is a complete window manager and offers the features of multiple different apps, eg it offers file management, terminal, pdf viewing, code editing, note taking, document/book reading. malleability programmable in a Lisp dialect; Great internal design choices (major/minor modes, keymaps, etc) Extensible, all in one, lightweight Elisp by far, sad that we never saw scheme for the browser. Extensibility, large community, packages for all needs. customization ( and org mode! ) extendability
keyboard focus user experience It'll be around for a good long time. Programmable. Focus on text editing. Flexibility. Keyboard centric. Customization, amazing ecosystem of tooling. The built in package manager and lisp make it an upgrade over Vim. extensibility, navigation, packages Extensibility
magit Consistent extensibility. dwim, dired, xref, eldoc, icomplete Extensibility, live introspection/modification, rich but text-centric UI, support for functional programming languages, comment filling. The ability to easily explore the functions it provides Customizability and creativity. productivity, easy consistent keyboard macros Extensibility. More subjectively, I find the ergonomics to be quite comfortable (although I type Dvorak) Extensibility, cross platform Extensibility and the huge amount of packages to customize it. Its extensibility, which is greatly leveraging by an awesome and active community. It’s ecosystem I feel productive when I use Emacs. It doesn't get in the way and I can tailor it to my needs. The freedom of expansion and customization of functionality provided by the packages Extensibility and programmability via a lisp flavor. Great packages provided by the community. Maturity, community, freedom, lisp, packages, consistency packages like magit and org-mode Extensibility & configurability The packages people write The ability to debug things inside of the editor is frankly amazing. Being able to modify code on-the-fly. I can always follow-functions of my editor and the code being edited to immediately have full transparency and troubleshoot outside of external language server issues. The flexibility that (almost) everything is written in, and can be customised with, elisp. Macros, rectangle replace, extensibility - Extensibility, built-in package manager.
- Built-in documentation, great community and knowledge bases.
- Possibility of doing almost anything with one software.
- Strong connection with free software.
- Not changing too much, too quickly.
- Longevity. Extensibility of extensions Amazing discoverability
Amazing packages Focus on text editing. IDEs use so much screen real estate for things I might use at the expense of the primary task Elisp programmability Extensibility, lots of non-programming packages, org-mode Being able to make small changes where ever they are required. Full screen real estate extensibility via elisp, community Extensibility and the package environment. Community, extensibility, interactivity and one ring to rule all the tools - Emacs has infinite tweakability. If some feature doesn't behave the way I want it to, or if adding some behavior would improve my workflow, I am certain that it can be done. And every tweak makes Emacs even better. I am slowly converging to the perfect environment for me specifically.
- Almost every function, command, and variable is fully documented and easy to query for. I seldom have to leave Emacs or turn to the internet to support the tweaking above.
- Packages to add a wide variety of features aren't unique to Emacs, but Emacs has a truly excellent selection, and I can always customize further.
- Emacs doesn't spy on me. GPLv3, wide language support, Orgmode Packages, customisable, keyboard driven Shortcuts and copy-paste functionality along with the respective packages is perfect for LaTeX editing as teacher / researcher. Malleability. I can fine-tune everything to my needs and taste. Fast and customisable - killer apps like magit built in That is basically an extensible Swiss pocket knife Extensibility, unique approach on different operating systems and possibility to use it in terminal and through SSH. * Everything is a buffer
* Using ELisp Community and FOSS Its foundation seems very well designed for extending, and it's got a lively community even now. Can be tuned and reprogrammed The extensions, and good VIM/Modal keybinding support. :w Its extensibility and packages. Having everything (notes, code, email) in the same tool, using plane text as its go-to interop format Elisp, Org mode. I live in Emacs. - Different packages and features work well together without conflicting
- Keybindings for everything
- emacsclient starts reasonably quickly, and shares buffers with frames on other terminals Probably the community that answers questions about how to do certain things on forums like stackoverflow. Continues to receive support. Simple way to edit files. Extensibility and key macros; search and replace features The navigation keybindings are really comfortable hackability, extensibility, freedom It has been here for a long time, and won't go away. Extensibility, discoverablility, age Extensibility and consistency Its built-in packages like Org Mode or Magit, its extensibility. Long term existence Evil mode, elisp, long history of stable elisp for packages to keep working on, ability to be tweaked to interface with almost anything, TRAMP mode Being mature free software, you can be sure that it's still going to be around in, say, a decade. The documentation is great, I don't like having to browse the web all the time to look up manuals etc so the fact it's packaged into the application is nice. And, of course, extensibility, especially that the extension language is a lisp (lisps are very well suited to such things). Its customizability. It's very freeing to have an editor where you can go from having the thought "there ought to be a way to..." to implementing that thing, very quickly, without having to fight with Vimscript. file-management Versatility, Hackability.
It's been around forever and will be around forever. Extensibility, packages, org-mode, if you really want you can stay in Emacs for everything. Extensibility, org mode, packages Long history; extensibility the extensibility The richness of its introspective capabilities combined with a Lisp programming environment Modularity, extensibility Customisable, trustable, powerful Interactivity, extensibility Core is extremely solid Customisability. Hackability that enables users to implement nearly any feature they could desire. Perfect vim emulation. The best Git porcelain (magit). Org mode. Extensive documentation and access to the source code (of both Emacs core and packages). Doesn't consume excessive resources. Supports IDE features through LSP. Can draw images in GUI. The extensability Text editing features, org, and huge package library GUI, built-in features/packages Total integration Extensibility and Elegant Packages and community. open source, programmable, fully customizable down to the tiniest detail. Lisp. Can't have emacs without it. Cross-platform (runs on MacOS and Windows)
Total and complete control over the editor (but as long as a project is OSS this is mostly irrelevant)
Not written on Electron (Yeah, that's just silly)
Old as dirt so there is a lot of packages for _anything_, granted they are all pretty terrible in quality but great for ideas on how to properly do things The ability to do nearly all my tasks in a single application Documentation - being able to easily see all the options and get explanations for what's going on in any pane without internet is amazing. 1. Key bindings that make sense.
2. Extensions/Libraries that do anything.
3. Org-mode changed how I write.
4. Magit changed how I approach projects.
5. I use Dired as my file manager. elisp, elpa Extensibility and composability. Being able to absorb many workflows with high customization (but it has a price as well ;)) Configurability, flexibility. Malleability, package ecosystem, one of the last "cross-platform UI" frameworks that doesn't drag in a browser and/or 3D engine for rendering. The use of buffers for everything together with the possibility to adapt how the buffers behave by means of Elisp. I've barely used Emacs for a month, but I think its extensible nature. I also like that it is easy to use and has a built in package manager. full customizability and extensive integration between parts Free software, org-mode Extensibility and packages eLisp, runtime. programmable, keyboard driven elisp, packages, community The extreme customizability and extensibility are unmatched in any other editor. Writing in multiple programming languages working pretty much equally well as each other. Customization and great packages (Org, Gnus, Magit, etc.) Extensibility, Org-mode extensibility, packages, like org-mode and lsp-support Speed and extensibility The packages that extend Emacs. The extent of customization. it is programmable editor It's customisability and extensibility. - Ths availability of magit aka the best git GUI I've seen, period
- It's core scriptability, despite Elisps weaknesses as a language, because it means Emacs can keep adapting to almost anything modularity, freedom, longevity Comprehensive package ecosystem and rapidly improving support for languages and tooling across the board. LSP integration, Magit, Flycheck/Flymake. Extensibility and a community. Elisp interpreter, introspection, passionate community, built-in documentation, Reddi and discord communities. Emacs is easy to debug and extend. I've run into issues with other editors in the past and often found that the piece of broken functionality is closed source. Additionally, it's a lot easier to extend than other editors I've used - can just eval a piece of elisp in a buffer and see if that worked, then figure out how I want to persist the solution later. Config extensibility and packages Customization, the number of packages that are available and the great community. Its keyboard-driven focus.
Its high level of customisability that allows for things like EVIL mode. Extensibility, integration of the tools (computing environment) Adaptability. Self documentation. Packages, Extensibility Long time stability and extensibility Programmable, extensible, evil-mode configuring, being lisp-based Editing Extentablity extensibility, community that builds it Being built on elisp and fully extensible. Which led to great packages that don’t have equivalent everywhere else. Like org-mode, dired, magit. However, others are catching up on these very fast. Org-mode, Evil is a good vim emulation Extensibility, programmability, Lisp, free software General hackability. If you want to make it do something even if it doesn't make sense for anyone but you, it's easier to mold the editor in that way than any other environment I've worked in. It can be programmed to do anything. Combining existing features with small ideas, resulting in bigger things that were initially unimaginable. There is so much you can do with Emacs, the only limit is your own head. The extensibility and the programming language modes. Flexibility and duration of continued development. I want an an editor that I can make mine and use as long as I want. Customization, community, proven by time. Extensibility, covers all the languages and scenarios I care about, org-mode, runs on all platforms Customizability, Extensibility, Developer Community attention to detail, OrgMode Mix of build in and community packages that make it complete computing environment. Dired, Erc, Gnus, org-mode, magit to name a few. It is customizable beyond belief. There is a package available for virtually everything. Consistancy through the years, everything that worked when I started using it still works. Extreme familiarity; after perhaps 45 years, there's a lot of muscle memory built up. Switching buffers and moving the cursor position within a buffer. I used to use Ivy, now I use Consult and Vertico. Without these packages, I would have stopped using Emacs. Org, extensibility it's infinitely configurable and customisable its quite portable when it comes to elisp - Flexibility to browse multiple items at the same time - many windows, many buffers, each of them having a different thing (a file, e-mail, directory) in it.
- One editor for multiple, sometimes niche programming languages. comprehensive customization with a plain-text config file Programmatically ingesting / interacting with displayed text and other systems The discoverability and self-documenting features, along with its extensibility. Only the first part would be ok, only the second part a mess, both together are wonderful and very much how computers should work extensibility, magit Extensibility and common platform to interact with many different tools. Extensibility. The packaging system. Orgmode. Magit. extensibility / programmability / one tool to do it all Extensibility, customization and being available everywhere. When a new platform comes along, I'll be able to use emacs there, with all the support code I've built for myself.
The incremental nature of emacs is great for learning, if you realize it; you can (mostly) treat emacs like notepad.exe (but see my comments about terminology in the difficulty question) and gradually learn new features. Its extensibility and the package system Unparalleled packages and customizability. Can modify it with elisp. I can use it for editing any language on any platform that I need. GPL. Extensibility, speed, amazing package management, great features Extensibility & open tooling - It is endlessly customizable and I can configure it to work (almost) any way I choose
- By offering so many services it reduces my need for the mental context-switches when bouncing between different programs Hackability, community. Based on Lisp, and self-documented feature, and the REPL Magit. Unlimited extensibility, easy to modify any key binding, persp-mode workspaces are in one window which is useful. Elisp. By far, elisp. Vimscript and VSCode JSON/TS make me puke in comparison. Following that, simply how it integrates beautifully, and composes so well for tasks like managing emails. Message-mode is the best composer I've ever used. Not to mention that it's extensive, in a way I cannot name. The other day, I typed in C-h f treesit-query-compile RET and it took me to the source code. I've never seen that before. C source code, mind you! Not to forget that it's extremely powerful out of the box, and now, since it integrates tree-sitter, eglot, PGTK, and others, I can confidently say that it (has the potential to be) is above and beyond all other editors, uncompromisingly. (E)lisp as the substrate and the long-grown set of features. Consistency across the ages and incredible capability The extensive ecosystem and extreme configurability. Great packages: Magit, org, etc. Mostly unified way to do things. The Community. Specifically: The big focus on having incredibly powerful extensions that are entirely controlled by the keyboard. Easy customization Org-mode, Magit, ability to inspect its own code, Libre software - Code and buffer navigation is insanely fast
- Same tool regardless of the programming language or file formats
- Quick to use in daemon/client mode it is extensible, it has many packages, it is FLOSS Extensibility. It's theory of operation. Internal documentation. It's a kit to make your own editor I think the keybindings are really great as well as the new lsp feature Extensibility and customization. It is a tool to be forged rather than a prescription to be filled. it's an interactive and re-programmable environment with full access to source Customizability, ecosystem & community org-mode, extensibility Longevity, Packages and Customization Selfdocumented, extensible, configurability, programmability, multiplatform Freedom. A great community. It is continually being extended. None - many packages
- extensibility Mouse independent It has incredible versatility. Org-mode and extensibility Ability to use proportional fonts. erc, magit, notmuch. Customization, lots of packages, stability, resource consumption It's as fast as vim, but it has better packages/add-ons and better features, like the calc or dired real keyboard only editor First class user extensibility, fully introspectable workings Self documenting is fantastic and being configured with a fully fledged programming language. It's fun Documentation, sheer number of packages, long-lasting community As answered before, Emacs' greatest strengths are its extensibility and community. The rich collection of built-in features and the ability to configure it using Emacs Lisp. Packages that support any language I want to try. The ability to hack it. Keyboard-centric UI. A GUI for the occasional graphics programming (editing svg for example). elisp and packages Coming from vim, having a genuine GUI helped. Also wanted org-mode and to learn new keybindings. Its a all in One tool with great integration e.g. magit, mu4e, .... extensibility, all rounded editor/os Built-in discovery and documentation and extensibility Computers should serve the user. Emacs allows this by allowing me to extend or customise every aspect of the experience. Through Emacs I can work and interact with the computer the way I want in a manner that best serves me. This gives huge productivity and quality of life gains. There is no other piece of software that has contributed to how I use a computer as much as Emacs has, which is why after 12 years of using it, it remains a constant for me while most other software I use has changed over the years. Extensibility, existing packages, open source Extensible, integrated environment regardless of feature The universal nature of it: I can get comprehensive help about all the packages and modes I use in a single way, I can view their source, I can navigate different types of buffers in the same way. Eshell is a great example of this. - Scalability
- Documentation (quality + offline)
- Built-in features
- Bridges between packages/features (links, org capture, bookmarks, grep output in a dired buffer, etc) Free and Open source, Lisp , Community of Hackers Extensivility Extensibility and uniformity of interface Stability. Extensibility and the possibility to integrate workflows (mail from mu4e make entry so i can see in org agenda etc). Great LSP and it's quite nice to have pretty symbols in LaTeX documents. It's useful to be able to write and overwrite very very specific behavior in particular. Packages.
Exploration of other UX paths than the mainstream Battle tested packages for every situation, relatively logical keyboard commands across all experiences, text processing mentality instead of button clicking interfaces, the only design of the interface is the color scheme and font which allows absolutely perfect focus on things. Nothing is distracting and everything is just pure. Extensibility, Tight integration, built-in help, ability to inspect the lisp environment as it's running Extensibility and productive features and available packages. customizability and extensibility The ability to customise pretty much everything and that the default way of implementing a feature (by the devs) is to give you a lot of options. Great user community. Programmable. Wide variety of packages. The entire UI is buffer-based text I think Emacs when properly configured is a fantastic word processor and text editor. That it's essentially a "LISP engine" and doesn't use a configuration language like VimScript.
This makes it extensible, down to the core. LISP is also a great choice of language. Endless possibilities. Org mode and it's extensibility, magit It is one of the oldest editors and very extensible thanks to the best language, LISP! Moreover, GNU Emacs is at the heart of the free software movement. Long live Stallman!!!! configurability, community Extensibility, org-mode, keyboard-driven Frames Everything works together, eg spellcheck in git commit message buffers extensible, customizable, versatile Extensibility to create a set of tools to help you solve your problem. (not being dependent on a Marketing organization's take on what I need) Emacs lets me work on almost anything as plain text Enormous feature set - 10K commands! Excellent documentation. Org Mode. Mouse free operation. Everything is a function. Orgmode its full adaptability to the hand of the worker The package ecosystem - extensibility while keeping the interface of the extensions compatible. The approach to customizability of a live lisp system where changing settings consists of running sexps and the level of configurability that brings. You can make it do just about anything, and tweak just about any aspect of it you want. Extensibility, “introspection-ability”. Extensibility, there is such a rich ecosystem of packages out there. Extendability. Customizability. The ability to debug it. Programmability. The "live" extensibility. Evaluate some elisp and run in right then and there. EVERYTHING could be tweaked Scalability Its legacy: there's always some new mode or feature you never knew you needed, and only recently found out about, but that someone has worked on for the past years Extensibility, Keyboard-focused modularity Extreme customizability, large community, discoverability (through c-h v|f|c) Extensibility
Live envitonment Extensibility, the package ecosystem, default editing commands, builtin packages and features Boundless extensibility, debugging, introspection. All the power and flexibility of a lisp system. Extensibility, discoverability, packages, community, Emacs Lisp, org-mode. potential for usability Introspection.
Being centred around text based workflows. Elasticity in adjusting it to the needs of an individual user, general features for manipulation of any text, the fact that it’s light on system resources. It can do anything, but lately I am using it more and more in org-mode as documentation and numerical analysis tool in one (usually sage or python, sometimes octave). It is good replacement to Jupiter. Also taking random notes in org-mode. Extensibility, great packages, helpful community Programmability, packages Community, editing, orgmode, ess can stay focused on the home row of the keyboard Programmable Extensibility, introspection, self-documentation. Extensibility, support for new languages, cross-platform Everything. Org mode, org roam. Editing speed, packages - doesn't get in my way, lets me focus on the text
- there's a package for everything Minimizing context switch by allowing me to do all my work in one tool, with a keyboard driven interface. Auto-documenting, dynamic (C-x C-e & friends), stateful. Powerful TUI framework without the limitations of the terminal (e.g., via 'make-frame-on-display'). Emacsclient. Extensibility & configurability. The fact that I can make it do exactly what I want via macros or writing my own functions makes me want to do everything in it. - Extensibility/ Power
- Community It's extensibility, simple but powerful GUI, and consistent interface of using functions and symbols for everything. Keybindings for almost everything. Extensibility and the many excellent packages available, accessibility (particularly modus-themes), self-documenting, graphical capabilities, and of course the community. Org-mode, it's great even for doing things like novel outlining, worldbuilding, and writing fiction/prose in general. The extensibility/amount of configuration possible is exciting in itself, it's crazy to think that doom emacs is just a bunch of config files! Orgmode. Introspective (self-documenting), written in Elisp, comes with excellent packages (dired, calc, org, vc). It's extensible and has a great eco-system. Customizations/extensions Support of the FSF All extensions of the base functionality are changes that I purposefully implemented and fully understand. No in-your-face novelty features I'll never use. Extremely fast. Straightforward configuration. Has replaced pretty much every other editor of all types I've used in the past. Presentations, papers, code, project management can all be handled seamlessly. Operating system integration. I have text, programming, a shell all in the same environment. If I wanted to do some java, intellij would give me a great experience. If I was willing to pay. But what if I suddenly get interested in clojure or haskell. Now I have to change environments a long living software project that is not beholden to the interests of a company Speed, flexibility, default GNU keyboard shortcuts Extensibility, integrations with OS Extensibility and being pliable towards the user's needs. Customizability, breadth of supported platforms I can customize anything, usually reasonably quickly. It's nice how "flat" emacs is, in that everything is elisp and quickly accessible -- user custom configurations feel like they are at the same level as packages & built-in elisp functions. Extensibility and being free software. Proven relevance across many epochs of computing. I feel comfortable investing in my preferred Emacs setup because I see myself using it over decades and new packages provide the support for new languages.
Orgmode is amazing. Use it everyday and discover new ways to improve my setup. Its package ecosystem, and the community that continues to tirelessly maintain it. To be clear, I'm referring to the Emacs maintainers as well as the thousands of people on GitHub / the internet building packages and Emacs distributions that continue to care about giving us a mature and *modern* development experience. Highly customizable Customizability, Control over everything, Integration of features to form a smooth workflow Being an all-in-one program. Being able to have a hotkey sequence for just about anything. Extensibility. I can have all the tools and applications that I want to use bundled into a single application with a unified configuration. Email, RSS, SSH, kubectl, password management, note taking, IDE, etc. The package library and how universal it covers multiple needs. It's a distraction-free coding environment that you can start using as simply as you'd start using notepad, but can be configured to be a fully featured IDE. You don't have to leave the terminal to use it and so it can be used from any environment: local machine, remote machine, docker container, Mac, Linux, all in exactly the same way. Also a bonus is that learning the emacs shortcuts also works in the shell outside emacs. Performance, stability, compatibility over time Customizability. Free software. Community. Future-proof. Long term stability. Doom really did bring me back to the platform. Extensibility, community, packages, freedom Phenomenal vhdl-mode package. General tweakability. Extensibility and keyboard driven workflow. Great joy in forging your own tools.
Extensibility, freedom, productivity. the packages Extensibility, customisability Customizability, great editing capabilities, org mode Unified interface to anything that can be represented as text. Can be made to do anything. Keyboard macros work everywhere. Programmable. Longevity, customizability The fact that it is so extensible. If there's a missing feature, there's a package for it. If there's no package, you can make one. Familiarity, programmability It's light, it has first class extensibility (almost no other editor is as easy to extend and has as much API for extending), it supports all languages/tools I can think of The Community that keeps it alive. LISP! Org Mode, extensibility, Elisp, adaptability and configurability Org mode, and LSP compatibility It's highly customizable and the language used to do this is a LISP (in contraposition to some custom configuration language) The extreme flexibility to be able to change the whole editor if one so desires.
The general structure of Emacs and how easy it is to change subtle things to better fit ones workflow.
The ability to change things at runtime and instantly see the effect of the changes. Extensibility is huge! Uniform programmability Free and hackable Beautiful, clean user interface, extensibility, magit and other awesome packages, GPL The ability to customize it to make it very efficient for your personal use cases. Community, Lisp, exemplar documentation, many existing packages, self-documenting, introspection. Molding to user's needs Extensibility, documentation, community It’s a Lisp machine. Open source and long lived. modes, shell Integration (emacs is my shell within MS Windows, it gave me a smooth transition from Unix to Windows), man buffers in one Session, simple but strongly adhered namens conventions, C-h a apropos, helpdesk,
extensibility Extensibility macros/elisp shortcuts Customization and extensibility; it is easy for features to be changed and added by the user or by community-made packages. Community ecology is good and anything is possible Virtually unlimited adaptation possibilities. Org mode with Babel. I spend 90% of my time in emacs in org mode writing and testning ideas Keyboard macros,
org-mode Extensive key bindinga community, introspection, debugging Extensibility, customizability, cross-platform, GUI and Terminal modes of operation. text editing Extensibility, implementation on multiple platforms Amazing community, high extensibility and GUI/daemon/client support. The fact that it integrates a lot of linux utils in one and it supercharges them. Also, Magit intergration with unix philosophy. Being free and extendable. Keyboard-focused, Configurability,
elisp as configuration language instead of vimscript or a non-extendable list of options like in vscode extensible, functional large and easy-to-extend feature set which is very well documented Community and Lisp Extensibility, and extremely full featured. Customization and extensibility. Being able to write a small package or set of macros to speed up tasks is a massive help. Extensible feature The fact that I can edit all files (buffers) with the same keybindings.
It does not matter if I'm in the shell, viewing log files, reading man pages etc. Extensibility
Stability history, community, extensibility, elisp, keybinding system Extensibility and customization. Task automation and the ease with which anything can be automated. Magit/Projectile/org-mode The flexibility It's applied metaphor and extensibility Clojure support and very light editor keybindings, and usefull extensions My vim and emacs setups are functionally equivalent, the thing that keeps me in emacs is Magit and the GUI feels more like an editor for some reason. customizability, extensibility, usability, built-in help, community elisp, customizations. Extensibility. Multiple modes. Orgmode. Magit. extensibility, flexibility Extensibility, timelessness Emacs greatest strength is that it is a Lisp interpreter. Extensibility, no doubt. I can tweak it to my needs. I really love Org mode. Org roam is also great Emacs as a lisp machine, introspectable, and tangible. Extensibility giving you total control over everything. Especially with exwm. Community, packages, malleability Extensibility, especially the ability to extend in an ad hoc way by live evaluation. Providing common facilities on different OSes. -flexibility
- packages The packages and its extensibility. And org-mode Can configure as you like Editing text is the same, no matter what job you are doing. And being a proxy for almost all work on servers "great operating system in need of a text editor" The extensibility and echo-system You can make it do whatever you want, besides coffee. It’s available everywhere Ability to change almost everything Open source, highly customizable, versatile The clear extensibility, the ability to create programs that operate with the editor interface and components Extreme extensibility with a large library of well-maintained/well-documented community packages There are lots, but the thing that has me continue to use Emacs is it's ability to do both code and prose/note-taking really well. My job has evolved from mostly coding-focused to a lot more researching trade-offs and note-taking, and org mode is great for organizing those projects. It's lightweight and has a good macro system Its customization abilities. Extensibility and lots of quality packages available for install. The fact that I don't have to switch between the "Command" mode and "Editing" mode to write & edit code. Elisp, community-driven lisp. in my editor. Still improving after so many years. Active community. Feels like $HOME Introspection and customizability. ESS. which-key mneomics in spacemacs, evilmode
It was a pain to setup IDE (IntelliJ, VSCode) and window managers on different OS (MacOS, Linux).
So, I replaced the OS experience with emacs. Exactly the critique that was around and keeping me on VIM, that emacs is an OS with a text editor, is the reason I'm using emacs now. I'm tired of all this crappy OS with their crappy tools. I've only to take my emacs with me and it's irrelevant on what machine I'm working. - Not bloated both in design and visually
- Keyboard shortcuts for efficiency keyboard-oriented workflow Extensibility. Amount of functionality. Programmability; generalized user-interface Self-documentation
Community I want to say extensibility, but Emacs Lisp is horrific compared to any other Lisp since the 80s. I understand the historical reasons why ELisp is the way it is, but that's little comfort today. I must then say it's the packages already written, such as Magit, SLIME/SLY, org-mode, etc.
Since I primarily write Common Lisp I would much prefer an editor that's written in CL and runs in my CL process. Really, the only reason why I'm still on GNU Emacs is because there's yet to be any good Common Lisp Emacs-like editor that I can use. Once one is made I will likely be using GNU Emacs solely for its excellent packages. - Extensibility
- Strong commitment to openness with nothing proprietary
- Pragmatic (still allowing integration with proprietary systems when necessary) Extensibility and API documentation (self-documenting system) Platform portability. Very handy when I had to use Windows. Same bindings for different languages/frameworks, then all that carries to TRAMP. Learn once, use everywhere comparatively lightweight, extensible, can become the best tool for YOU. That it is Lisp-based, and pretty close to common lisp. Kind of like MacLisp-style. I VERY MUCH agree with the idea of having everything in the same namespace (no packages). Everything available directly without any weird boundaries.
I think Emacs is the best example ever of a highly complex system built that way. And is sooooo cool Having tasks, agenda, mail, notes and IDE in one place, all linked to eachother. Power Extensibiiity orgmode, magit Extensibility. That it is a lisp machine. Customizability and its community 1. Very low barrier to changing the editor. I can make deep changes by just typing some lines of Lisp into my init.el, I don't need to recompile anything or register a plugin through some special API.
2. Great vim emulation through evil-mode.
3. magit and org-mode.
4. The ability to use one program for many programming languages, documentation, LaTeX papers, and my personal knowledge base.
5. I trust the FSF not to include telemetry and not to play tricks to make people use proprietary software. Elisp, free software customization, consistent key bindings among many packages/modes, open source, elisp, elisp source Emacs combined with i3wm allow me to create a very efficient workflow where my hands hardly leave the keyboard. Ability to fully customize programming workflow FOSS and extensibility Hacking every functions configuration as code Extensibility, configurability, complete freedom The community and customizability.
"There's an emacs package for that" It's ability to be my all-in-one for text. Everything in one where you can change something if you don't like how it's setup by default. does everything I need Hackability, longevity, allround support for programming/prose/misc stuff Universally available, consistent interface, extensible. Emacs strives as being a platform for building composable and extensible applications to interact with a computer. Extensibility. You can code the program to a way you want it to work. Dedication to community and the GNU project, and staying away from centralized control. Openness to including user submitted packages in the base distribution. Elisp is also quite powerful and cool, and at fingertips. Extensibility while still being lightweight. “Modular” design. Extensibility and packages, especially TRAMP. capacity to evolve The ability to do more useful and faster actions without the gosh-darn-awful mouse. Having a familiar computing environment on whatever system I'm using. You can use it for almost anything, and tweak it to do what you want Remote editing, eshell, workflow automation The community that develops packages like magit, lsp-mode, ivy, projectile etc That you can mold it to become anything you want simple Flexibility/Customization Homogeneity (a unified environment to do anything), introspection (you can learn emacs and elisp inside emacs), dynamism (you can change emacs while running), community (lots of third party packages and helpful discussions) multi platform. extensibility. Extensibility. Everything can be done from emacs. Lisp, extensibility, self-documentation and discoverability. Extensibility. Emacs can be the glue between a lot of different activities. Extensibility. Keyboard based usage it is the complete package. all you could want. all configured in the same language. keyboard shortcuts, support for many languages, speed Works in a terminal
Interactive code evaluation Extensibility, keyboard oriented with Bash like keybindings, searching interfaces (Ivy/Helm). All the packages and the "lispiness" of the software itself (i.e., being able to interact with everything). Support for huge range of programming languages; org mode; customization of appearance and functionality Openness, universality, no nonsense Extensibility: the fact that many parts of my workflow can be done within the same tool, i.e. with the same keyboard shortcuts, etc. Libraries Discoverability by introspection, self-documenting, opennes Extensibility, documentation, and how easy to see and apply your changes Package quality,
Same keybinding for every apps. CIDER
rectangles 1. How every aspect of the editor is hackable and customizable.
2. Amazing packages (e.g. org-mode, magit, ...)
3. Documentation Essentially being a Lisp VM with text editor utilities, and all the introspectability and flexibility that flows on from that. integrated with elisp so be extensible Philosophy, extensibility, community. It's longevity. I feel like I won't have to "learn" another text editor ever again. Customization and key commands Extensibility, I can customize it to suit my needs. Versality and extensibility: I use emacs as my office tool suite. Make it do whatever you want it to. extensibility, gnu license Freedom, flexibility, amazing packages, having a GUI Ability to extensively tweak your emacs configuration for your specific workflow and preferences Rich ecosystem of packages and great user community. Provides functionalities that are more than a plain text editor like file permission tweaking and interfacing with the OS. The extensive, comprehensive, well-written, sometimes humorous documentation which, unlike some other editors I could name, seems to actually want everyone to be able to hack on it in a substantial way, even if they're not an expert in programming text editors. Extensibility and powerful core features like dired, completion framework and org mode. fully customizable from head to toe, and the libre and kind atmosphere from emacsers i know Being a Lisp machine which is fully programmable, software freedom (GNU/FSF) Not having all the features turned on by default I think the simplicity with which you can extend it is really nice. Most changes to your workflow are usually just a single function away from being realized. It’s an interactive lisp machine, fully programmable - Buffer manipulation
- Built from ground-up with extensibility in mind
- Good introspection and documenation facilities
- Surrounding package ecosystem
- Elisp as configuration language Portability Extensibility, and the packages ecosystem that has grown due to the extensibility. It's actually an Elisp interpreter, which makes it much more extensible. works in remote consoles
extensibility/flexibility Extensibility, self-documenting, open-source Extensibility and customizability.
Also, text being the first class citizen. The ability to bring everything into a single workflow under common keybindings Introspection, help system and community It's easy to setup and use a system for working on larger more complex projects Optimized apps all in one Introspection, extensibility, community, org, magit extensible via elisp package ecosystem, moderate use of resources Extensability and customability. Its modularity and extensibility. Magit, org-mode (babel, org-roam, agenda), built in GPG support Extensibility and org mode. Everything is text, good quality packages, many languages, strong history. it's flexibility and the whole ecossystem where people help each other getting along with new technologies The extensibility, the ecosystem, the community Vibrant package ecosystem. Lots and lots of things that can be done in emacs that are often not done anywhere else. - Ability to run in terminal
- Very fast editing once familiar with the keybindings
- Versatility: I'm using it every time I'm editing text Extensibility, elisp, community extensible, open-sourced, Lisp flexibility and ability to bring a common(ish) framework/interface to multiple languages. Lisp, existing packages. Not corporate, and doesnt change out from under me. doesn't sell my data. Feels friendly. The extensibility and the control given to the user. - Extensible
- org mode
- and other awesome packages Extensibility, customizability, and the wealth of packages people have shared over time. Ability to customize the platform. Ability to interact with code. extensibility, keyboard driven its large community and its extensibility Flexibility and extensibility
Interaction between many packages
Runtime inspection and debugging Very big user base, and a solid foundation, allow for very good quality extensions. It's plasticity Extensibility and a great community that solves problems that people care about. Longevity. Emacs will probably outlive me. Packages and functions that I find on older blogposts or forums (2010 and below) will work perfectly fine in modern emacs. I can write simple emacs functions to extend the program to do exactly what I need. Shortcuts, org mode, packages, configurability Very powerful. Extensibility, elisp, org mode, plugin ecosystem It has Coq support It is so versatile, always works, extensible and Lisp! opens anything, programmability It's extremely flexible, and has a large community of useful packages to make text editing especially efficient. Elisp, and the depth of history/packages/documentation/lore. Org-mode for knowledge management and task organization.
Outline features usable in different document packages (pdf-tools, rfc-browser, etc.).
Extensive customization possibilities, which allows one to have a text editor hyper-augmented that fits almost perfectly its needs. Extensibility and Community Extensibility, free as in freedom, community, org mode extensible, there is a mode for everything, not resource hungry, integrated shell Extensibilty.
Ability to override any behaviour (I.e. with advice, literally *anything* can he altered)
Ease of language. Elisp is a simple language with few (no?) hidden surprises. It was easy to learn for a noon like me.
Very easy access to specific documentation (describe-function and friends) Org mode + ability to fully configure - Generalism - It's an extensible and configurable window and operating system.
- Comes with basic support for multiple programming languages.
- "Can do pretty much everything if needed" (though "Lisp programmers know the value of everything and the cost of nothing")
- Being keyboard driven
- Project age, philosophy, integration of ideas of those who built the open source extensibility at will with lisp Every keystrokes are just invocation of elisp functions. It runs everywhere, is easily extensible, and has a large ecosystem. Flexibility. Tools. Runtime introspection extensibility and readability of the language you use to customize it. Extensibility, history, self-sufficiency Any aspect can be inspected and its behaviour modified elisp, core primitives for building applications with Emacs UI elements, such as text tl;dr: its extensibility. We can live inside emacs, usually I have 3-4-5-6 (right now 5) running emacs's on different workspaces, each of them having multiple windows, and each windows having multiple buffers.
Keybindings: programming very fast without even touching the mouse. Extensibility through packages
Customization options are endless Customisability and Extensibility Timeless. Will always be there. Many of the packages provide first-class solutions. Lisp is very powerful and allows Longevity, extensibility, consistency on different OSes. More stable than Vim, great packages very well maintained. Light, extensible. extensionality You can handle everything if you want. REPL and interactivity extensions, great support for programming languages, org-mode, magit Lisp os extensibility, longevity Community and packages Elisp, Keyboard based UI, Open Source Code Range of packages, flexibility. Ability to do basically everything elisp, built-ins like calc and dired, and communities like Org, CIDER, Irreal blog etc. It's capacity for every kind of text editing that I ever want to do. Driving from the keyboard. Great packages like orgmode and magit. Extensibility. A lot of people use vscode now but AFAIK you can’t edit the internals of it as easy Everything is configurable Endless customization and entirely keyboard oriented. Ecosystem Extensibility. It's so nice to override/configure any functionality you don't like/that you want One editor for all programming languages, no IDE required Org mode, dired and compiling projects/running commands (better than vim) Integration of multiple programs/languages (e.g., ess for coding/running R, then embedding R code in LaTeX using knitr). Documentation and programmability - Extensibility
- LISP-based configuration
- Packages extensibility, interoperability between packages / major modes / minor modes I can make it as simple or complex as I want -- a simple writing prompt or a full fledged IDE. Extensibility and org-mode Extensibility through packages and elisp Its versatility in customizing various display features and its integration with other utilities, such as shells and debuggers. being a platform for editing applications Allowing me to create my custom workflow fairly easily Providing a complete programmable system that works nicely for prose and code without being too modal. Free Software, no telemetry, lightweight, EWW, Gnus. Introspection, elisp, orgmode The fact that the GUI isn't just a terminal, it has styling, varying font-sizes, and SVG support. Freedom to do whatever you want Ability to change anything to my preference extensibility. runs on most anything. I run it on everything from linux on my pinephone to my mac Extensibility! (elisp + (require 'cl)), stability - both interfaces & doesn't crash, ubiquity - available on almost anything. Spacemacs makes using emacs very easy. Enabling and disabling layers is very simple. The vim bindings are also very good and helped make me transition to emacs Open Source, useful features, endless flexibility Packages are more stable compared to Vim. Highly extensible -- a package for everything I need -- which allows me to do almost any text editing jobs from within Emacs. This saves me time learning my way around new editors, as I can just use the editor I know. Org mode, extensibility, community, free software ethos open, extensible, great community Extensibility, self-documenting, moldable Structural editing via paredit, and composable extensions, when they do compose that is. Being extensible, self-documenting, interactive scalable Native application. Not a web front end with JS garbage. History and involvement in the free software community. It's an editor for the lifetime (I watched this video right before jumping in to Emacs https://www.youtube.com/watch?v=VADudzQGvU8). Extensibility, being able to accommodate any feature I want without too much hassle Discoverability, Daemon The possibility to write huge packages in Elisp, like org-mode or AUCTeX, that are applications in themselves and integrate with the rest of the system. And the possibility to write a Mode for, say, a certain type of configuration file, with relative ease, so that many people have done it. Extensibility, stability (my Emacs knowledge will still be useful in 20 years), and the Emacs community/package ecosystem Extensibility, can do "everything" The ability to be everything and to be customized. Org-mode is also a strong argument. The command completion is amazing: using nvim before I often forgot how to do things, here I am reminded everytime of the key-bindings. It is free software, and it's actually a super-extensible Lisp machine. Extensibility and cross-platform compatibility. I can depend on Emacs to do nearly any text operation on any computer at any time. packages management, extensibility and some excellent packages like magit. Interoperability through shared environment. Easy to switch buffers and create/remove "windows" using keyboard. Privacy friendly and extensibility and freedom Thoroughly complete, powerful, extensibility, huge number of packages customizabilitt Simple, lightweight (comparitively) no GUI! One editor/ide for all languages -- I don't have to switch my environment when working on a new project.
Org-mode is unrivaled as a tool for thought
Extensibility means if I don't like something, I can fix it. Emacs Lisp, Extensibility, Documentation, Community Org Mode - especially for writing (academic) text, mixing code, citations.
Packages - having (M)ELPA got me back into Emacs. flexability free, lots of other people use it so they've written many tips/tutorials Extensibility via elisp
Minimal initial setup
No forced notifications and auto updates Extensibility, huge number of packages for all conceivable purposes, org-mode, magit. Internal symmetry Org mode; longevity; extensible Extensibilty, Introspectability. architecture, despite its shortcomings emacs is a platform that allows you to run full applications inside it
org-mode is a huge strength that brought me to emacs Some packages (magit)
Same keybindings, text nav in all languages
Integration with some languages (Clojure) Extensibility and self documenting That everything is subject to modification and extension. Extensibility, great self-documenting environment Extensibility, customizability of every aspect of the editing behavior Users have the ability to configure their environment, whether for writing prose or code, to their needs and preferences. Moreover, for beginners, tons of packages will likely already provide the functionality they're looking for. It's a comfy experience once one has their configuration near their desired state. Some of the packages are top notch (magit) Extensibility and customisation possibilities Great text editing, stable, long-term community - the time I invest in Emacs will pay back dividends over decades. Extensibility and robust package ecosystem. Stability. on-the-fly macros, org-mode, lots of movement keybindings, not modal like vim extensibility and flexibility Extensibility, self reflection works across platforms, powerful text editing Elisp + community Community, Extensibility and matured packages for almost everything the extensibility and the community. You can build anything into emacs, and the community actually works on it's issues, including really useful packages into emacs, native comp for speed etc. self documentation and help systems, extensibility, image based programming (no compile restart cycle, like with Common Lisp), undo nearly everywhere, minimal but efficient UI, the power of the lisp machine (living code)
extensibility (see point one)
everything is a buffer Integration between different tasks, common interface for different tasks You can change it's behavior to your liking. Its massive versatility and customisation capabilities which mean I can do everything and anything I like with it. Open-source rocks :) GNU EMACS: CREEPING FEATURISM IS A STRENGTH
from Beautiful Architecture book Easy to install and configure plugins.
Extensibility through elisp.
Decent keyboard based workflow The extensibility, that I can make it work for virtually all my use cases. Its extensibility, customisability, the power of its text editing abilities, and its ability to interface with the rest of my system. That it is easy to extend and two packages in particular: ess and org-mode Extensibility Eco-System Community
Not being spyware also helps Extensibility and exposure of everything over a singular interface (currently elisp) Extensibility, on-the-fly modifications, customizable. Its extensibility and its community Keybinds and not using a mouse Fast, extensible, good REPL workflow Powerful built-in features. A real built-in programming language that can be used too easily and quickly extend or customize emacs. Org Mode, extensibility Customizability, DOOM, snippets, org-mode, 90s vibe Completely programmabile extreme customizability Culture, elisp, org-mode, ethics, variety of themes, all the smart people using it.... org-mode... Integration of Lisp with text editor and system libraries in combination with character based renderer similar as in text consoles (TUI). customizability, extensions The enjoyment of building your own configuration. Flexibility and power when you start to wrap your head around elisp and the package ecosystem. variable-pitch-mode packages and org mode Longevity (35 years of computing I am sick of changing all the time). Fast, simple, clear. Emacs will never die. The community is active and very devoted. It can do everything and is infinitely customizable. extensibility, have no need for switching applications Org-mode and the whole org environment, the emacs community, it's infinite customizability Extensibility, introspection GNU licence, everything is text, keyboard driven, elisp, shell-mode. It's fun to extend it with elisp. org-mode. Extensibility and REPL Its community Extensibility through lisp. Integration of multiple computer features through a central interface. Extensibility, live update of its behaviour through `C-x C-e` Extensibility & customization available via Emacs Lisp. Being a lisp interpreter.
Not using electron. Extensibility through the elisp interpreter Extensibility
Changing behavior at runtime keep hands on keyboard.
Mouse is not necessary. org-mode and org-roam extensibility & stability Org mode and magit. Extensibility - Support for both terminal ui and gui
- Support for Daemon / Client
- The amount of packages
- Faster to use without a mouse
- Keybinding is good to me Extensive package set. Great IDE once modified to my liking. Great customizability. Comprehensive Emacs Wiki Extensibility. Self-documentation. Stability. Extensibility, lots of built in packages, community. Open source, extensible, incredibly passionate & helpful community Limitless customisation Malleability and a great community of package authors pushing it forward Emacs Lisp, and how easy it the language makes it to hack every part of the user Emacs interface. Extensibility and FOSS It's a very good framework for TUI applications. I don't actually use it for editing text very often, but I always have Gnus and org-mode open, and often use notmuch. front-end for many terminal applications as built-in and custom user packages Customisability/Extensibility, packages, the fact that it's not exactly a text editor Easy access to internal funcs/states. M-: and eval-print-last-sexp.
Do VSCode allow the same? The elisp environment and the rich library of functionality makes it easy to customize and extend. composability, the amount of code that exists and works together Introspection, extensibility and ability to integrate with external tools Programmability / extensibility none Extensibility, power functions Extensibility, ecosystem (org, dired, magit), community magit, org-mode, good haskell support Implementation consistency, extensibility, ease of inspecting the implementation, decades of useful packages. Elisp, gnu, the fsf Extensibility and magit org mode. Lisp because I can change how things work and debug on the fly The great extensibility Not needing to switch between IDEs all the time. You can just get very good using one editor over a life-time. And works everywhere I work. The easy extensibility powered by a sane and expressive programming language. This sustains a very good ecosystem of community packages that often show a wonderful synergy with each other. The inherent tweak-ability paired with huge amounts of sample code, documentation, blog tips, etc. Stands the test of time, but integrates modestly well with new technologies Extensibility and good support for many different programming languages Customisability, either very simple (for writing prose) or fully featured (for editing code) Having a Lisp as it’s configuration language. I think emacs' _second_ greatest strength is how every part of it is documented at multiple layers - in keymaps, in code comments, docstrings, info manuals, the git history of packages, in blog posts and forum posts, in the collective conversations on IRC - and how emacs itself makes it easy to connect these pieces and navigate across them smoothly. Even how elisp encourages the writing of good docstrings with the tooling that makes use of them builds on this strength. It's everywhere you look, and that sets a compelling, enduring example for everyone who contributes to the tool and its ecosystem.
But I think emacs' greatest strength is that every part of the tool and every package seems to be built atop the implicit bargain that you don't need to learn the whole thing to make use of the pieces. There is a deeply baked tradition of respect for the process of incremental learning. It's a deliberately crafted learning curve which does not punish newcomers (well, much) and yet also continues to reward wizardly experts who decide one day to dig into dusty corners and always, always find new treasure waiting there to have the dust blown off. Same config and keyboard shortcuts in all environments. Org-mode seemed really neat. Packages for almost anything I wanted. Magit, Projectile, Dired, Rest Client, Eshell, programming language support. Probably the keybinding, and the built in lisp support Flexibility and portability. TRAMP and uniform dired/file interfaces are awesome. Extensible
Useful built-in tools (dired, org, eww...)
Feature discoverabillty (with apropos and C-h )
Modes Customizations Fully customizable, and I can fix most problems on my own. The package library, org mode is really useful Configurability, good support for multiple languages, the ability to do everything from a single program. TRAMP is very very important to me. History and Developer Community uniform gui model and extensibility Extensibility and can be run in TUI mode Staying power, customizability, availability extensibility
the way it has been developed for such a long time
cross platform Flexibility and extensibility. Extensibility, efficiency, keyboard-drivenness (is that a word?) self-documented Keyboard macros; built-in "packages store"; self documentation; GDB interface; awesome packages like lsp-mode, multiple-cursors, yasnippet. Extensibilty, org mode, notmuch mail, Just Works extensibility, documentation, how configurable it is org-mode and tramp Openness, extensibility, community. Elisp, extensibility above and beyond what is reasonable for most other editors. Combining almost all my tools into one. Customizability that I can maintain and transfer easily. The way it rewards sustained investment. Extensibility, and some great packages by emacs community Customisability, extensively, integration with other systems (compile, grep, language server) Long-running free software project.
Exposes its Lisp interpreter for scripts. Extensibility, speed Wide range of packages available Extensibility, one-stop shop for many different needs, integration with external tools, discoverability, integrated help/documentation The fact that it's a full-blown dynamic Lisp environment Ability to modify things at basically every level. Self documenting. Extensibility, solid package ecosystem I can change almost any definition on live and see how it changes. Multi-platform. I can re-use my same config across multiple machines/platforms with ease. Extensibility. It allows me to make appropriate changes to Emacs when my workflow changes. It allows me to experiment with different workflows altogether and not be tied to someone else's opinionated view as to how something should work or be used. I think a lot of the other strengths of Emacs (e.g. great packages, community) derive from the great extent of Emacs' extensibility. Customizability with a huge ecosystem to pluck from. Emacs just coming up makes me happy. Malleability, user experience for power users. extensibility and reliable interface Extendability and the ability to connect together multiple parts of a text-based workflow. Emacs combines a wide range of capabilities out of the box (e.g. org-mode, calc-mode) and can be adapted to do even more. It surprises me regularly with what is possible, like using a latex math expression in a calculator, which is positively insane. Documentation, plugins ecosystem, extensebility Any text editing/programming job can be done at many levels of setup (none, vs. ligth, vs. lsp with additional bells and whistles). On top of that, everything can be managed using org-mode, org-roam and projects/projectile. being a uniform interface to anything Extensibility, using a powerful and fun language. Extending functionality takes just a few lines of code, customization is a breeze. Extendable Customizability, Extensibility, large package ecosystem Customization and extensibility. Configurability/extensibility. Discoverability, inspectability, flexibility, ability to be modified at runtime Extensibility, many ready packages, GNU-compatibility by default (GDB, mit scheme, and such), debuggability, excellent documentation, helpful community. It's the last lisp machine in use Capability to export text into any format. Can use every programminglanguage I want. Adapts quickly. Make notes and programm in the same tool. orgmode, extensibility Unified Workflow that can be extended to all usecases. Extensibility, open customization Integration with operating system, it's remote connection ability (TRAMP, etc.) and the fact that no matter what platform hosts it, it works the same. It levels out the 'under the hood' experience. Biggest genuine strength: Being able to open multiple buffers in multiple "windows" (what the rest of the world would call frames) and jump back and forth without using the mouse
Biggest fake "strength:" Emacs key-bindings and the general UI paradigm are so different from the rest of the world that once you get used to it it's physically difficult to switch. This is more "addictive" than useful, but it's kept me from switching for 20 years. (It's like saying heroin's biggest strength is the painful withdrawal symptoms) Extreme customabilty and composeabilty of functionality. for example only Emacs has multiple model editing packages and innovative "evil viper meow boon (xah fly keys)". With other programs you have to rewrite from scratch and while using one of the above you can keep stuff like dired magit etc... full keyboard control, fully open and extensible, decades of packages and best practices Free sprit and strong community It's extensibility allowing me to use muscle memory in an extensive range of tasks. The extensibility and the packages that add up so much to emacs, like org-mode and magit (for programming) Extensibility
Fact that it helps me focus solely on code in front of me
Not having to use mouse to do stuff
Built-in help Daemon/client model - being able to access the daemon from desktop or terminal (e.g. via SSH) Versatility, can do practically everything Emacs can be anything you need it to be. It is the original batteries-included editor. Anything that I have ever wanted to do in emacs has already been done and someone has a package I can use. In the rare case where I wanted something really specific, I was able to add it in lisp in a few minutes. It is a fully programmable editor. Allgood Extensibility, Flexibility, and breadth of features Introspection, and the customizable nature of everything. There's a core set of packages that are just stunningly powerful. Magit alone is worthy of an award. Dooms keybondings org mode, the ability to preview latex as youre writing it, lsp, easy customization through doom
mainly the graphical stuff that is a headache to emulate in vim
oh also dooms vim like keybinds, and deft Customizability, no coorporate owner QWAN Portability and customizability. TEXT EDITING CAPABILITIES AND ORG-MODE AND DIRED-MODE Customization.
Solid bet (free software, won't disappear) One editor for all purposes It can do some things better than Code Browser 4.9, but it can not do that what Code Browser 4.9 shines at, Folding of Code into Sections, Navigate into Sections, Link to Sections --> Hyper Code Where it itself is written in Emacs Lisp and there are few parts that cannot be customized. The variety of packages available. I Can turn it into anything I need. It runs on everything. Over the many years I have been using Emacs, it has always proven to be able to do whatever I needed it to do. once you learned it it's a skill adaptability to many tasks, ability to automate repetitive edits, integration with command line tools . infinite possibilities Small gap between being a user and being a developer: Emacs is introspective and modifiable at runtime. coding efficiency Macro recording ctr-x ( The ability to fully customize how you interact with information and the program itself. Community packages and code snippets are invaluable. As a beginner programmer it gives you the feeling that this is an IDE that can grow with you throughout your life It is super extensible and can be programmed to fit each person's needs Packages, they have lots of control over the working environment, and they're easy to install. Configuration by elisp config that makes very powerful extensibility. org-mode, non-dependence on web, programmability, community Flexibility, consistency Free, extensibility while in the running program. Lisp makes it very configurable. Org mode is great. I have confidence that Emacs will work in thirty years. Do what I mean
Do what I want
Community Extensibility and the fact that I can use it for just about everything and only have to master one interface. Works in the terminal. Many great packages. All the already provided functions via `M-x` and the packages (the community) Don't need a mouse to do anything. It's inherent extensibility so that I can deeply configure things exactly how I like them. Lisp makes Emacs very extensible and configurable. Because it is a free software, I trust that Emacs will be around in thirty years. Extendible. Community Lisp and age Stability and flexibility Speed of producing text, speed of the program itself, hotkeys Flexibility and configurability Configurability. Package library. Everything is a text buffer
Extensibility It's ecosystem. I think the feature death the extensibility is pretty awesome. Every time I thought of something that I really wanted it to do, it couldn't figure out how, I eventually discovered it. Built-in fully customizable Its extensibility and openness. Self-documenting, and a nice blurry line between configuring the siftware and simply writing your own branch. That it's highly configurable and you always find somebody who already solved a similar problem to yours. Extensibility and customization, and great, powerful packages Its extensibility and wide array of built-in features. Extensibility, configuration Not doing things that i don't want it to do Lisp OS Eternal nature pretty powerful customizability / extensibility capabilities; efficent ergonomic primarily keyboard focused human interface; fairly performant, versatile and stable (lately); addictive keybindings (pro and/or con?) keymap Hooks It's extensibility. Elisp! The great community! Cross platform! Tool integration, for software development, but also general knowledge work, etc. doesn't get in the way I can take the tools I learned to a new language Ability to be highly configurable, and also one environment for many, many programming languages. Package ecosystem, open source With other editors, I have to learn them. With Emacs, I shape it to be the editor that I want. Free Software, Extensive Community, multiplatform longevity, extensibility Endless flexibility. You can do a loro of things in it. Documentation, stability, versatility Fast
Extensible It's lightweight and reasonably fast. The tight integration of the Elisp runtime within the editor. Extensability/Hackability, easy insight into the state of the editor Built-in function such as org-mode, the vast ammounts of custom pagages and the ability to create my own funcitons and kbd-macros. Architecture Many useful concepts, such as narrow, marker, windows configuration, inferior, etc. and helper functions.
These functions can help implement complex extensions easier than other editors. Modularity, extensibility, customization Extensibility and Flexibility.
Remote editing without prerequisites on remote hosts.
I can do so much without leaving emacs (except web browsing but i think this is for the best, security wise) Plugins, lisp, extensibility Allowing me to fine-tune its settings to adapt to my ever-changing workflows. Awesome ecosystem, packages like magit... The possibility to customise perfectly it to your needs. Part of GNU Lisp and the flexibility it provides (and the wide ecosystem which resulted from said flexibility) Strong and good performing extensions. Longevity of the extensions and they just continue working. That I can use single software for everything I do. I can keep my keybindings consistent during these activities. It is also extremely easy to write my own packages. I'm a Lisp and Prolog programmer, need the REPL for everything I do. Same for Python.
Don't need the mouse
Works the same everywhere Keeping the dream of the lisp machine alive. Org mode, packages, flexibility/programmability Active community of users and developers Free, extendable, dedicated community. I can tweak it for my needs magit, eshell It's extensibility and it's usage of LISP (specifically Emacs Lisp). The programmability of the editor. Extensible (elisp), packages IDE in the true sense of the word introspection self documentation, discoverability, customization and especially org mode Keybind extensibility as compared to VSCode. More interesting packages from the community(things like hydra, which-key) as opposed to VSCode. interactive customization Extensibility, customizability, huge collection of packages Extensibility and customisability Light, open source, community-built Extensible by a powerful programming language (elisp) Ability to extend and reprogram from within Emacs while Emacs is running. For me, Slime for common lisp. In general, customizability (that's how slime is made and without customizability I wouldn't have Slime) Extensibility, open source, packages Introspectiveness, the fact that it is designed as a lisp machine with an attached editor makes for a very great customization experience Emacs Lisp, philosophy Extensibility in emacs lisp Without a doubt the greatest strength of Emacs was designing the tool around a core Lisp VM. It's a Lisp environment with features that work together to form the impression of a text editor. The extensibility, the ability to work with a fully fledged programming language, with for extending emacs itself as well as solving external tasks (like maintaining JIRA tasks). Extensibility, consistency (ability to do “everything” and thus offer a consistent interface for everything) Extensibility, packages such as magit Extensibility; and documentation such that extension is not a mystery Extensibility and the customizability, these are really different ways of saying Elisp, I think. - Doom Emacs, because you can try Emacs at its best without any effort at all. Vanilla Emacs doesn't make a good pitch for what Emacs can do for you.
- With org mode, I am the sole owner of my data. It has never been on someone else's servers.
- Everything is linkable to org (magit commits, mu4e emails, etc). The more I do in Emacs, the more I can link into org.
- Superb lisp programming environment. Given enough effort just about anything is possible. And the rug will never be pulled out from under you. Keyboard driven workflow, extensibility for tailoring your functions to the work you’re doing, and teaching it’s users about excellent software. Some of the plugins and all this talk about org-mode I can bind any feature or function to anywhere on my keyboard, and I can customize anything, even in most 3rd party packages - Large set of key bindings allowing quick editing
- Org mode Extensibility, obviously, but also the fact that you can do all of your development, documentation, and personal productivity in one place. The REPL-driven development for dynamic languages and the integration terminal is fantastic. Extensibility, freedom Free Software, can be tuned extremely precisely, some packages (magit, org-mode). Flexibility, fired,. .. eloquent setup and config Coherent interface. Everything's a buffer, and I can interact with a buffer in roughly the same way no matter what it contains. No need to deal with a new application and interface paradigm for each type of task I perform or document type I view/edit. Customisation of the editor. It is fun. It's customizibility.
It's elisp layer, i.e., almost everything can be changed via elisp Org-mode
Inspecting and debugging the code directly Pure text interface, in a pinch even a menu or magit window can be copied into another buffer and manipulated
The package ecosystem is great. Workflows made possible through magit, embark, projectile, etc are second to none The plugins have plugins! Info mode/docs. Debuggability. The vast array of packages The single unified environment for keyboard oriented computer use. Extensibility and many mighty packages Text editing Extensibility, Interactivity, self documented, discoverability extensibility, the fact it’s a gui app (can mix fonts, show images etc), org-mode Extensibility, magit, distraction free Integration of dev environment with packages such as org-mode and mu4e in a common text based paradigm. Lisp ecosystem Extensibility, makes it stay usable over decades The huge ecosystem of emacs packages is really amazing. I don't prefer using online utilities, and emacs has alternative packages that fit (almost) all of my needs! Self-documentation, discoverability, configurability Extensibility & openness self-documented, customize by elisp, keybindings Extensibility, community. Elisp, keybindings, packages, community Extensibility with an easy language. I live in emacs. As a result I can tie tools together often with just a few lines of elisp. It's how computing should be. Ease of extensibility - A great non-cluttered UI (Dooms keybind interface is great)
- Much faster than IDEs (Jetbrains...).
- Highly extensible and automatable when needed. Editing text, configurability, support for many programming languages, many packages. An incredibly versatile text processing platform Extensibility, stability, openness, and freedom. Emacs strikes a good balance among all these, and encourages people to write excellent packages to allow plain text to do more than you'd think it could. The way so many things integrate with each other, like how you can use TRAMP to use SSH as an email server, or with dired to copy things from remote Docker containers to local media
Also org mode! Literate programming with a live session is extremely nice for walking through complex problems
Also, subprocesses, like inferior-lisp for hotswapping code into existing processes for instant feedback for anything you wanna try! Extensibility (lisp) + some very good code/packages already there. Orgmode in particular, among other things. clean abstractions, that still work well together Extensibility you're the extreme Extensibility & s-expressions Extensibility. The only other programs I use regularly are firefox for web browsing, and zotero - which just sits in the background to pass citations from firefox to the citar package in emacs. Org mode is another great strength. Existing packages, extensibility, flexible keyboarding system The extensibility and the trust that it will be there in the future. Runs anywhere. Extensibility with elisp, and the packages that come with that. elisp, customization, high quality (core and packages) Return of (Learning) Investment: Will be around in 40 years
Its malleability plus the wide range of topics covered by its built-in and 3rd party packages make it quick and easy to throw together something that really useful to someone's personal workflow -- it's almost like a RAD tool. (I've built a lot of tooling around the daily tasks in my job and that works really well for me.)
The quality of the documentation. Consistent UI, usable over SSH, package ecosystem, runs on many platforms buffers connected to processes programmability, extensibility, easy connection between packages Extensibility, incredible community and user base, integration across domains (being able to connect your org tasks to your codebase, JIRA and an IRC server makes life so much smoother) Great design and long term support. It will still be usable in the next 50 years. Usability after getting used to key bindings. Local extensibility is the main one. Being able to customize anything about the editor in your config file is a killer feature. This is something that Emacs has that VSCode doesn't. For VS Code, if you want something custom just for you, you have to write a package, with Emacs I can just write a function in my config and bind it to a key. configurability, can be programmed and extended High potential for inter-package synergy Customisability, extensibility, and the rich package ecosystem Ability to x-link between notes, code and mails (Org is definitely the killer feature) Real extension language, I can do almost all my tasks in Emacs. For me it's the ability to just write and execute elisp code on the fly, along with the control elisp grants me over my system. Oh, and org-mode and magit. support for most languages and user customization It changes your mindset opening to many more opportunities. Complete extensibility, ecosystem of packages, capable community willing to help, configured with Emacs Lisp extensibility, portability The packages and introspecability. org mode, extensibility Packages like auctex, or-mode, magit and such Extensibility, small footprint Being able to work with little to no distraction in a powerful environment. extensibility and large library of major packages vhdl mode Extensibility, Free Software Extensibility, Lisp, Org Mode Edit and eval any elisp at runtime 1. It is literally a Lisp virtual machine, which makes the environment unique and irreplaceable
2. The ecology of the software packages accumulated over the years Free software, in both cost and freedom, maintained by a community. special modes, elisp interpreter, ability to be used as an interface Stability, compatibility, extensible ELisp! One language. No fiddling with Python pips, Ruby gems, NPM packages, all to get various packages working together. Also a powerful language to extend itself as needed. Extensibility & packages. Documentation. No “insert mode”; just start typing. personally, i think the greatest strength of emacs is the fact that i can use it for quite literally all of my writing/text editing, due to the extensibility of it extensibility, ubiquitous nature Malleability, keyboard-centered editing Can be accessed on many systems, fast, configurable. (Sometimes I think it's too flexible and that I might need to install two versions to use for different purposes). Wide support from a very clever community, lots of history. Extensibility, feature completeness, OSS. I can do anything with it. Extensibility and Keyboard Shortcuts extensibility, Extentability, packages, community Extensibility, building ones own environment tailored to their needs/desires Extending capability. A full list of plugins and Org mode. Extensibility, commitment to free software principles, strong community, being able to read and change code in the running environment, the long history and legacy of work (many odd use cases have been catered to over the years, and perhaps some of them are yours as well). Very powerful yet relatively easy to get started with the basics – I was up & running in a couple of weeks but I'm still gradually taking advantage of more advanced/powerful features as I learn about them. Well documented either in the editor or online, I don't think I've ever failed to find the answer to a "how do I?" question. Any time you think "I wish it worked differently" there's a way to make it work that way (but if you're a relative newcomer and a non-coder like me then you may need to either ask for help or postpone implementing it till you've learnt more). You know, I can inspect my own environment and change its behavior during run-time. Also with living in Emacs (actually org-mode) I can maintain a great PIM with every pieces of info linked when it make sense and accessible from a grep.
Also text-macros. Longevity; stability; performance; extensibility. Cross platform, defaults work well, easily customized when a default doesn't work It can do absolutely anything, including posting time cards to jira Emacs Lisp. Extensibility. A thing Xah Lee has said, is the integration. y-or-n-p is a example. Compared to other scripting languages it's a advantage.
I find it incredible that it's possible to completely replace all Emacs keybindings, and even make a modal system. (talking about ErgoEmacs and Xah Fly Keys) Elisp + customizability (these go hand in hand) Customize ability Extreme extensibility, lightweight application, simplicity Tramp (with podman, docker and ssh in my case)
Interoperability with external processes (LSP in my case)
Great text editing features (with a few packages) Keybindings for navigating text, they are more sensible than the windows driven defaults. There is always that thing that allows you to do that thing.
Stability over feature.
they are keeping adding modern feature when possible, specially lately. Slowly but it's coming.
The big community, available on IRC, Reddit and Discord.
Lite (specially on terminal)
Customisable productivity Org-mode, extensibility, interoperability of components magit, daemon mode OS-like in the sense that you can do a lot without switching to a different app. Its community which writes clean and modular packages, extensibility Extensibility and community of users. 1. You can make it 'your own', it's malleable software, you can use your config on various platforms so you can have a 'home' on them
2. Emacs lisp is pretty nice as an extension language
3. History and principles extensibility, possibility to do everything from within Emacs. Extensibility via Emacs Lisp. Extensibility architecture, Common Lisp integration and debugging tools Extensibility
Universality (one editor for everything: text, programming, e-mail, calendar, to do) History/license/stance, buffer/text/input paradigm Source code is available, self-documenting and modifiable at runtime.
Emacs includes amazing packages: Org, Magit, Mu4e... that can be combined Introspection, extension, elisp, “os”y architecture elisp extensibility You can change almost everything to your liking works in GUI mode as well as terminal mode
built-in programming language
ORG mode Lisp, community, flexibility, portability, mobile-org Extensibility, packages and above all: org-mode. Reasonable resource usage for an extensible editor. Low barrier to changing things. Extensibility, endless functions that come prepackaged like gnus or are available via ELPA, MELPA etc, tools like Spacemacs simplifying configuration Continued development and improvement. Performance. Flexibility. its works and its fast(only when using vanilla) org-mode (with clock table), pdf-tools, org-roam 1. Cross platform reach -- even to non-free OSes. This has been my oasis at times when working in Windows-only or macOS-only environments.
2. Community. IIRC Emacs 23 and 24 with package.el (and anti-alias fonts) really sticks out as a watershed moment in my mind for personal daily utility of Emacs. Of course being in the moment with rising social coding helped, too. Interactive extensibility - Reliable (you can leave it running for ages and it works fine)
- Fast (Seldom slow to respond to user input)
- GNU project (respects freedom, assuming GNU Emacs)
- Uses a sensible language for configuration Good conventions, community and freedom from limiting coding principles Extensibility, still relevant after 50 years, plugins (magit, lsp), org-mode Seamlessly used over ssh. Extensibility with a huge community of packages. Its extensibility and community. rich capabilities for feature extension; platforms to learn lisp programming; all-in-one text editing and org-mode It is very comfortable, with great bindings. Robust, open, not tied to whims of company Being built on top of lisp, feature rich packages Emacs is always there for me! Emacs being free software and highly configurable are its greatest strengths to me. Extensibility and customization, both in functionality and appearance. Once the initial learning curve is overcome it's a very smooth experience using Emacs. Org mode is very useful for quick notetaking and organisation. Personally I currently don't use Emacs for things like email and git, but I appreciate that if you want to you can do a lot of things in Emacs alone. Orgmode, extensibility Community, Extensibility, Packages The packages for editing clojure are so good! Since it’s old tech, I’m confident it won’t go away and it’s very stable. org
Modes for small languages
Extensibility I think it has the fastest workflow of any editor I've ever used. I don't like tabs and I've not seen another editor that has had a tabless experience that works as great as emacs. It's even better with some extensions. Ability for people to create packages (e.g. org-mode, hyperbole or calc) for others. Fast, lightweight, extensive Evil mode Free/Libre Its extensibility and great packages. Standard interface across languages. Support for programming It's ability to adapt to change. It's package ecosystem and extensibility. Also org-mode. elisp and the documentation. Extensibility and quality of available packages like TRAMP and org mode. Org mode. Org mode makes Emacs more useful than any other editor org-mode, pdf-tools, ...
you name it, someone already built a mode for it. Extensability. Extensibility. Longevity. Also that it doesn't follow modern paradigms I see as a strength; emacs follows it's own trajectory. Introspectability: I hate not understanding why something happens. Org mode, helm Keyboard everywhere. Two things: Extensibility, and very accessible UI (e.g. M-x for commands). - Maintained by a community with no financial influence.
- That it's a runtime with first-class lisp bindings and text and buffer primitives. The lisp bindings give me the ability to do anything (even use it as a scripting language), and allow meta-programming. The primitives are able to serve as good abstractions since so many things produce and consume text.
- The length of time it's been maintained, and the steady hands that have guided it. - Elisps extensibility.
- Easy to get started with Elisp
- Community spirit Extensibility and stability. Remote Editing (I edit a lot of config files...) consistency and perfection of editing user experience over extended timeframe, now measured in decades. being a semi lisp machine Configurability. That you can work on the same text at a char by char level and a semantic level at the same time. Speed and key bindings Documentation + community and extensibility. The first two make the third that much easier to get into. Community and packages for extending without big limitations I use vim That its free software
melpa Doom Primarily that it is free software. Both in that it's hackable and here to stay. Its extensibility and universality (“it’s an OS, not an editor”) integration of functions related to my entire development workflow extra packages like magit, notmuch, eglot It's easy to configure and build your own "personal operating system". editing features/packages like magit etc the package infrastructure, confidence in long term survival Stability. Community. Simplicity and extensibility Easy to make my own functions to change behavior. I can trivially map keys to do almost anything. Great packages from the community. org-mode. This was the reason I left Vim. Modified it for coding a lot later You can tweak or extend almost anything, so that Emacs seemlessly fits into your workflow. Also: org-mode! Moldability
Keyboard-driven Legacy, simplicity, stability. The very mature system of features like overlays that make most editing modes possible, connected to a programming language, and the deep pile of existing functionality. Be a Lisp playground I own my text editor and no corporation can take it away from me.
Beautiful text in org-mode.
I can program whatever I want in my editor. org-mode, extentsibility and packages Being able to everything from the keyboard--usually without leaving the home keys--is a big plus for me. I find it very intrusive to have switch between mouse and keyboard with many of the programs I have to use.
Extensibility--both through the vast range of packages and by being able to program and customize emacs on my own.
Being able to work with code in a variety of languages in the same environment, with familiar keybindings, syntax highlighting, and, often, language-specific add-ons.
org-mode, which I use extensively for recording notes, and combining executable code with commentary. Customization, Packages, and Emacs Lisp. The ability to hook in to various processes. Its complete programmability, it's so powerful that its almost an OS unto itself Orgmode and its extensibility. The extensibility and package diversity. Institutional knowledge of editing, stability, packages I can use it for whatever desktop digital task I could be involved in. The extensibility and ecosystem Extensibility and speed one editor to rule them all I don’t know what it is but whatever makes org-mode possible.
In addition it’s flexibility to make it truly my own editor. Extensibility is the obvious one, but it has to be said. It's the difference between an editor that can eventually be made great and an editor that is forever stuck at adequate, though even extensibility is nothing without a community to tap into it, and to help each other learn how to do the same. I should also mention the uniform interface it presents between all the external tools it pulls in. Emacs is a text editor that can turn anything on your computer into text--web browsers, debuggers, playlists, directory trees, you name it--letting you apply editing commands in unexpected ways. Wdired mode is an example of this; running Occur on an EWW buffer visiting a large webpage and piping the matching lines (possibly hundreds of them) into a 'shell-command-on-region' before running a keyboard macro against the results, for example, is another. Extensibility and still works brilliantly on a tty Its a programming environment which helps build or work with other programming environments. Readable, easy-to-understand customization of basic text editing and the well-developed modes (e.g. org-mode) ELisp extensibility basically means I can always get the behavior I want... and since it's so old there's usually a package for it already that's customizeable in the way I want.
In terms of default emacs features, my favorites are:
tramp Extensibility and solidness, has been there for a long time Lots of builtin features, great extensibility, I like the way it looks (with all chrome switched off), great support for lispy languages. Also it's old and still going strong. Community open source packages. It's packages. Emacs' greatest strengths are it's extensibility, and the ecosystem it has around it. Having a calendar, fired, and mail built in is really nice! The fact that most functions you can look up the documentation on- and see how they are coded. The few that are c (and not elisp) has never been a problem for me. Customizability and documentation The ability to immediately change inner workings of the editor. The ability to introspect and customize the system while it's running is invaluable to me. It permits a kind of exploratory programming that lets me customize behaviours for specific tasks without needing to write/modify entire packages. It has made learning elisp much more valuable not for the big jobs, but for lots of very minor tweaks. Mostly just works, configurability Completely keyboard driven, extensive features via packages, light on resources, clutter-free UI, extensive configuration options, its fun to use. * loads of keybindings also valid in terminal (bash), which makes it easier than vim
* programming language specific plugins A Lisp interpreter at its core. Simple and minimal, but many many many extensible. The design of the system where the parts integrate with each other into a bigger whole extensibility; packages like magit, org Freedom and full inspectability are big. Extensibility as well -- everyone's emacs is tweaked to custom fit their needs. elisp! Longevity, community and breadth of tools. Customizability. Emacs is a fully functional editor out of the box, but the true strength is how you can build your very own custom environment and change just about anything. Extensibility, flexibility, LISP, community. The extensibility is the key to most of Emacs' strengths. Extensibility and self documentation Magnificent packages like magit, org-mode, language-specific modes, flymake, dired. Combined with keybindings across all domains and OSes. Extensibility, Org-mode. Extensive, I can organize all projects with my own requires; Org mode is really great, I can write my own blogs easily and happily. versatility, org-mode Text navigation key-bindings; [package] extensibility; integration with the OS. Extensibilty
Being nonchalant about fitting in to the mainstream Extensibility, org-mode, open source mouseless usage
mapping functions to key sequences ( for toggle file tree etc)
being able to write by own functions and routines into the system
I love that I can move my installation around and use the same setup on multiple machines asdf Introspectiveness, extensibility and "everything is text". Open source with human centric licensing. It's introspection and extensibility along with long deprecation windows. ability to mix normal editing with Gnus-style interactive applications seamlessly Emacs Lisp! :)
Native compilation has been great! A new garbage collector would be wonderful! The community and flexibility. The ability to interactively discover functionality via completion and search. Extreme extensibility, community package support (ELPA etc) It's heavily customizable with a decent programming language, and a lot of packages already exist. Community.
Consistency among use-cases. extensible, customizable Extensible with rich packages. 1. Extensibility
2. Community which provides documentation, packages, and innovation
3. Org-mode I like how extensible it is, and how easy and fun it is to work with Elisp. I treat Emacs as a live-coding environment for working with text. I also think the documentation and help facilities are very good. Lisp core => Extensible everywhere by default. new feature in 'competitor' is emulated in emacs before other camps have figured if the API can be extended Flexibility, discoverability, extensibility: a huge depth of usueful functions which are only a few keybindings away. Also fast and easy buffer switching. available everywhere, will be around longer than me, FOSS, can take my absurd config with me and be up and running on new (employer) hardware in a very short time Documentation, commitment to stability and backwards compatibility, configured through a "real" programming language. Extensibility and programmability Extensibility and vast number of packages Extensibility and having a native gui lets eMacs unlocks a lot of functionality that felt hacky in Vim. Packages like magit and org I can fully customize it Extensibility and excellent integration between a different modes. no distraction, extensive documentation, great community
most of my tools in one place. Extreme flexibility and extensibility.
Can handle almost anything.
Powerful editing abilities. Huge availability of packages free software, time-proof extensibility, macro recording Package manager, free-libre, infinitely customizable, available almost everywhere I enjoy most the introspection capabilities. I immediately liked the customization interface and now I appreciate more and more things like the help system, variable description, having the elisp source available in a click. One stop shop. Tons of standard tools (I wish I could learn faster about them). Flexibility, modularity, customisability Extensibility and well written documentation Extensibility and programmability. It can be configured to the very last detail Extensibility , Community, A damn free software that everybody can copy, make own, make new :* ,
extensibility via Lisp , minimal, From source C , It has well maintain compatible with modern hardware to old , games , Persistence - still used after 40 years. I also like using text for everything I can. I like being able to keep the same configuration of keys across different tasks. Extensibility in Lisp
Free software Emacs is a system, not an editor. Infinite possibilities. Its packages, mostly org and calc. The ability to run as a native GUI app, as well as function in a terminal (for certain remote editing scenarios).
Extensibility allows it to adapt to new languages and tools.
It's available on almost any platform.
The editing capabilities are extremely powerful. It is crossplatform, highly customizable and reliable It can become anything you need it to. It is simple, stable, and lets me stay productive. Some packages are game changer and I can not live without: magit and org mode. - having all things text-related in one place
- free software philosophy (it matters!)
- customizability Keyboard-centric UI, customizability, and extensibility Self documentation and that most of Emacs is written in its extension language itself. This makes it possible to change/modify its default behaviour or fix bugs very easily. Extensibility. If you want to do something specific to your needs, you can most likely use an existing package or write some custom Elisp to do that. Craftable and personal Configurability using elisp It does everything I need and probably everything I might need in the future. It's fun to modify and extend things via elisp. Freedom
Design Extensibility, "C-h f" "C-h v" are simple things that changes everything ^^ The extensive collection of packages You make it your own Extensibility and configurability using code rather than json Lightweight, takes less processing power than VS code. being free software, not being a web browser A unified computing experience thanks to an extensible 2-D text metaphor and cohesive programming language ivy ,vertico, helm search engine, elisp, extensible Flexbility, portability. compatibility, community, programmability (not just extensible, modifiable) Having a consistent UI for a wide range of text-based activities.
Discoverability (once I knew enough to use it)
Ease of customization and integration into different work flows.
Consistency between platforms. extensibility! can run code inline in the editor Its ability to evolve and transform over time Extensibility, Lisp built in lisp environment, org-mode, magit Emacs makes it learning and working fun while using. Packages, the ability to run on pretty much any machine, remote editing that just works your customize Every prebuild action is already also a function that can be used programatically. And then bound to a key. elisp and extensibility Mature project. Fast enough but full equipped The ability to tailor it for your workflow Flexibility, customization, integration with other tools. Everything is immediately available. jack of all trades all-rounder, extensibility Ease of customization and extensibility Extensibility, customizability and vast number of packages available from elpa. Flexibility and freedom extensibility, free license, customizability, learning curve isn't actually that bad The Lisp Interpreter and the maturity of plugins. Code of emacs and packages have little bugs and robust. Availability of source at all times and developing a go hack it together mindset. Extensibility. Community. Flexibility, longevity, and a great community. And org-mode. + The great level of introspection while running
+ Reasonable consistent behavior and patterns. Major package breakage is rare, for me.
+ Not too intrusive by default
+ Runs on all systems I care about
+ It free as in freedom A lot of packages with great commuity It’s secretly a great environment for elisp programs. Elisp is a good language and excellent for writing extensions (eg dynamic scope). So it’s possible to debug and fix issues whereas modern software can be buggy but hard or impossible to fix. The extensions are good. Calc is amazing. The documentation is so good. A truly absurd amount of extensibility It got something right with extensibility - Wonderful history and philosophy behind it
- I can do most of my daily work from within Emacs
- Makes me feel smart.
- I enjoy being able to read the source code and tinker with it easily
- Not only configurable, It ENCOURAGES you to configure your own Emacs. Pushes you to be creative. Freedom, Lisp & Butterflies History, package ecosystem, extensibility, freedom. org-mode
Other packages that are good, too. Configurability, supporting anything, huge number of packages by far its extensibility -- being able to rewrite core parts of it as it runs is extremely powerful Extensibility, flexibility, longevity, availability on wide variety of modern platforms, open source Customizability, elisp as the extension language. Lisp. If it weren't for Lisp I would 100% be using something else. Ecosystem. Its extensibility via elisp. Text editing features, packages exosystem, extensibility Extensibility, programming language support Elisp, extensibility, customization, org-mode Extensibilty, packages and community. Entirely customizable, being able to edit elisp source code and mutate state without compiling or restarting, long history of peer reviewed code, good documentation, consistent UI standards (e.g. ‘g’ to refresh view).
Powerful built in packages/modes. Ability to separate data from interpretation. Faith that emacs will be around in 50 years. Doing things “right”. Extensive. I rather think of Emacs as a lot of tiny and interlaced improvements that I appreciate as a whole. I program in many languages and emacs gives me a "constant" experience (build, compile, test, git,...) Extensibility/Elisp Elisp extensibility Extensibility, image rendering Lisp programming customiztion It's age, which I think is the cause of both it's stability and the amount of information you can easily find online for nearly any issue that does come up. Always surprised to find features and tools I never would have imagined Extensibility. I can keep the same editor while doing lots of different tasks, and programming in multiple different languages. The recent LSP work has made this much easier. - packages
- extensibility The model itself, where the editor is a collection of functions triggered by events that can be key pressed or mouse gestures or whatever, and the functions themselves can be redefined at any stage. Flexibility, not needing to switch IDE from coding to writing blogpost, notes or technical papers. Distraction free UX Micro-communities around it, like doom-emacs community Full control via lisp Full featured and customizable for my
Workflow Its programmability using Emacs Lisp, it being free software and it being a consistent, cross-platform working environment. Simplicity of extensibility. Being able to very easily extend an editor is a very nice feature that is missing in most modern editors. I prefer emacs aproach to configurarion and extensibility. I also prefer it’s graphical interface. The incredible package community. Packages, IDE-like features, efficient movement/keybindings, customizability (programming emacs itself) Macro, elisp, packages Extensibility, availability, versatility Extreme extensibility and customisation One editor for everything; customization and extensibility Killer maintained packages (e.g. org-mode); extensibility; dedicated community It's a great upgrade from Vim with its extensibility and great support for vim bindings via evil which VSCode struggles with for example. org mode, you can probably still use it in 40 years Extensibility: you don't need a package to customize something, you can do it by yourself - extensibility with decent programming language
- org-mode, mu4e, magit, and few other packages
- gpl It has very interesting core concepts, such as major and minor modes, which makes it incredible extensible and can implement any workflow / other editors. Extensibility, Documentation, Community and Packages (inbuilt, org-mode, magit, etc.) Extensibility, good keybindings for text editing that are also used by MacOS Open source and continued history of active development with a consistent philosophy. extensibility and fast and efficient text editing features. Elisp customization; feature-rich. Text editing, extensibility and that I can make it my own Open source, hackable Kind of standard, lots of functionality, extensibility Configurability, Being able customize both the packages and the editor text editing, great packages I think that its greatest strength is file surfing and being able to manage windows with hotkeys. Oooo hot keys are great! Its transparency, in the sense that the source of any function can be read and changed immediately. Freedom/Code accessibility/Community/Free software as a learning experience Extreme extensibility Extensibility and community orientation the community, elpa/melpa, It just works! I've had hundreds of buffers open for weeks on end, no crashes. org-mode, viper-mode Use Lisp to configure everything of the editor The super low barrier to entry to start extending it with the user's desired behavior + the homoiconicity of lisp It doesn’t get in your way. It is extensible. It has many mature packages. It’s easy to configure (with the right packages). Tramp , org, iedit, multiple cursors, regex builder, undo tree, undo region. Extensibility and the Community around it the fact that Emacs is not a text editor, but a lisp interpreter that works beautifully as an editor It’s design: Modes, map, hooks Extensibility: ability to easily customize almost any aspect of the editor and try out customisations immediately using the elisp REPL;
Org mode flexible, lots of great packages, able to inter-connect different things / aspects of your life via packages written by the community Extendability + it contains a language interpreter. It's an OS masquerading as an editor. Editing speed, ability to customise, pleasure of using, extreme power, incredible flexibility, high ceiling for power users, confidence editor not going away so worth sinking learning time in It automatically closes paranthesis and can display them in multiple colors
And it has a cool git integration Keybindings & available everywhere I need it. It's malleability. Nearly everything in emacs is not only "configurable" but actively exposed to the user to be changed at runtime. elpa/melpa Org-mode, Evil-mode, flexibility. There are jokes about Emacs being an OS but excluding startup process it is a lot faster than the js based editors. Really good for Lisps and interactive/incremental programming. Supports non-mainstream languages well. Extensibility, customizability, keyboard-driven command interface, wide variety of packages Editing, Extensibility, Integration of data between packages. Being able to copy text between this and that. Being able to work on everything via text. Extensibility, community, Org-mode It is free software with great customization capabilities. What are you using after Emacs? VS studio Emacs is really straightforward to learn thanks to its introspectable nature, this doesn't mean that the learning process is easy, but that there are really good ways to learn just enough to get work done and understand how the editor works at any level Relatively easy extensibility Everything is customizable on-the-fly via elisp without mucking with plugins written against some stupid APIs. magit and evil mode.
introspection Extensibility and wide range of packages available. Plus org-mode. Customisability. Buffer model. Modularity and the global surrounding environment Discoverablity + tons of packages + customizability extensibility through lisp The conservativism towards superficialities and dedication to free software. Its programmability, complete customizability, and TRAMP Cider, magit, and tramp Extensibility and Keyboard Macros Keyboard focus, org mode, magit I like the little things, which may or may not be configurations stolen from a friend. Easy to navigate with a keyboard. Fun things like rectangle select. The highlighting on non closed tags. I'm using other editors more now that my work is forcing me, and my biggest issue is that I was much faster finding errors in my code or an xml file in emacs because of highlighting or other behavior. It has so much capability. I love the commands and buffer management, and that I can browse files in the editor Org-mode, great built-in documentation, high discoverability of functionality, and a decent package ecosystem. It's really org and babel that keep me around. Tweekability extensibility through elisp. Platform stability as a user. Emacs just gets better over time. If I develop a workflow around Emacs, I have confidence it will just work with minimal fuss. Extensibility, customizable Malleability. Each of us can make it whatever we want it to be. extensibility, wide range of packages, great documentation and community ready to help you literally in any situation It's one tool for many things. unified interface to everything, mail, writing, versioning PlainText and flexibility fun to use, extremely customisable Wide availability of packages and stock completness. - customizability
- flexibility flexibility
many modes for programming
org-mode Extensibility & customization Extensibility, packages, batteries included Low on resources, and keyboard driven, and the extensibility That it's fully introspectable and hackable. Its extreme flexibility, and exposing the complete internals of the editor to scripting Emacs Lisp and its extensibility. The customizability. Extensibility, power, intuitive keybindings, enormous ecosystem Its main strengths are the power of its editing commands and the quality of the packages available e.g. Magit. The built-in interpreter and from it scriptability and extensibility. It provides a way to tell Emacs how to do things, which many programs lack. Extensibility, Everything is readable as text, org-mode Extensibility, org-mode and similiar (org-roam) Extensibility with high quality packages such as Org mode, Org-roam, which-key etc. Very extensible with Elisp, a great and helpful community. Customizability, self-documentation, ubiquity, flexibility (GUI + Terminal accessible) The Emacs community and the vast number of available packages. Lisp interpreter at the core. Extensibility. Natural beauty. Cutting edge nostalgia. Extensibility, documentation, community and libraries. Everything is text (combined with Git, this is a super-power), and nearly any task can be trivially automated. 1. consistency (e.g. M-x ... to find and invoke any interactive function of any package; same basic navigation keybindings in any/every mode)
3. self-documenting (built-in tutorial, C-h a, C-h c, C-h m, etc.)
4. mouse free (ergonomical)
5. ubiquity (terminal emacs likely available even in a fresh vm)
6. lightweight (compared to heavyweight IDEs like IntelliJ) Power and flexibility. Works quickly, is eminently configurable, and Org-mode is a life saver. Mallable Consistency over time Emacs is as usable 15 years ago as it is now and and i know that it will be supported for the next 15 years without any risk of it suddenly going proprietary, and suddenly not supporting the OS/Hardware i choose. Also the knowledge that it will most likely support any future programming language. Lisp backend, Org-Mode, magit Extensibility, better vim than vim Ecosystem of users and packages. Customizablility extensibility, ease of writing little interactive functions Can be run in GUI. Elisp > Lua > Vimscript. Has useful help commands. Customisable, packages Org Mode, large "marketplace" of extensions integrated text-based environment, extensible, opinionated
also support for lsp is very important runs on many systems, and has superior code/text editing capabilities vs other options (excluding vim) customilzied, lisp-liked langauge The programming language. I can find packages that support odd languages like XQuery that don't always have good support on other editors. And Emacs works very well in tmux over an unreliable network connection. org-mode and other extensions Modifiable Configurability: the potential to change everything through packages and variables; Flexibilty: everything can be changed at runtime, at will; Lisp machine Open source, extensible, fun to program Extensible in lisp, open source, healthy package repos with good variety/coverage. extensibility, and lots of ready to use community packages Easy access to any functions. Introspection, and being able to lookup most functions/keybindings via C-h f and C-h k. Flexibility and extensibility. You can find a package for just about anything. And you don't need to use a mouse, which I do consider a big ergonomic plus. Can be used for pretty much any text based activity, highly customizable, and reduced context switching. FOSS, Extensibility, lack of Electron Being able to truly make it my own. Evaluating elisp functions in any buffer. Included extensive documentation. Quality of third-party packages. Relatively lightweight (memory, cpu...) compared to modern editors. Their extensibility. Also if you can imagine some feature, you (or someone else) can implement it. - It's a pro tool and stays true for years (no attempts to become newbie-friendly)
- User experience doesn't change for years, unless you as a user decides to change it youself (so liberating in the age of things changing and breaking all the time without you being asked if you really needed it)
- Text editing is superb (I write ALL the texts, no matter if a computer program or prose) in emacs, because I'm 2x more productive with emacs Extensibility
at-the-coalface text manipulation and navigation
freedom Definitely extensibility. Being able to advise existing functions, hack on whatever you want to fit your editor to your needs it great. Coherent system with lots of powerful tools built in Reach and extensibility.
Emacs tools are built to solve a problem broadly - not by coupling the tool to a specific way to solve that problem. Integrated extensibility extensive amount of addons Documentation is Emacs greatest strength beyond extensibility. Extensibility, good workflows (and related snippets) available online; It's a Good Text Editor Extensibility, flexibility, packages. You can turn it into whtever you want. It's a framework for text editing applications. Free software, extensible, great packages Magit.
Good GUI while still relevant for CLI.
Doom Emacs. Programmability; and the ability to inspect the code and look up documentation for the code that runs the editor itself - Easy to extend and customize
- Simple core abstractions allow great interoperability between packages
- Larger packages that integrate tools into my development workflow: magit, lsp, ...
- Small packages or features not easily available in other editors: projectile, wgrep, macros, ... Org-mode! Programmability extensibility & community Extensibility and configurability. Extensibility, opensource keybindings, unified UI for different languages Being able to do everything NOT being an editor, in the modern sense, but a "computing environment" where the editor is just the main UI. Modern UI struggle to be document-UI, we have switched from widgets for anything to the modern web, to notebook UI etc and still most UIs are far behind Emacs... The combination of vim keybindings and which-key make it the ultimate experience.
But also, it's endless configurability and emphasis on documentation
Also, magit is amazing I think once you click the whole "it's not an editor it's a big ol' REPL" sort of thing, everything gets really powerful. As long as it's text it can be coerced nicely into Emacs. Key binding, extensibility, community The ability to easily eval code in the editor environment.
But this is also a weakness in that a lot of the config is done via bespoke code rather than some sort of established protocols. desktop saving, RCS and git plugins Extensibility and that it is an OS. Its extensibility and rich ecosystem of packages. It's packages for all-purpose Configurability, extensibility, terseness, kitchen-sink approach, understandable. Great availability of packages, especially those included by default. Programmability. It is a programmable text manipulation platform, including editors. Extensibility and stability Free software principles, extensibility/adaptability Its maturity and the maturity of its packages dabbrev-expand, dired-mode, LSP support Org-mode, magit, now eglot The extreme amount of "customization" one can do via lisp. extensibility, rich packages, org mode, community, it just works unlimited extensibility. I can switch off that toolbar, which is not helpful for me. I can use magit, calc, org-mode, etc. whenever I desire. Easy and powerful integration of packages through elpa/melpa, powerful packages available.
Easy extensibility. Vast amount of features Extensiblity Existing ecosystem of plugins Ability to change the behavior and customize Elisp.
Lisps are great for quickly writing or modifying packages. Integrated interpreter and features that have been tuned since decades (for instance search works in a pretty complicated way but it is very intuitive to use). open source, custom keys, communication with shell, ability to tweak commands elisp for better and worse, package repositories No telemetry. Extremely configurable. All included Soo many features You can tailor it to your exact needs. You can also inspect the code it is running and patch it yourself (e.g. advice-add). Extensibility with Elisp, good set of default packages. It's very extensible and it adapts to my work flow Extensibility, text formatting Shortcuts Emacs' greatest strengths are its extensibility, its lispiness, and its freedom. It's lightweight (ram, disk, and cpu usage are low). It runs on many different OSs. The package system makes it infinitely extensible. Extensibility and org-mode. configurability with elisp Extensibility, Elisp, and the fact that it appears to be Eternal Configurability, extensibility. More than just an editor Customizability, wide community support, terminal interface with daemon/client which is not available in many other GUI IDEs programmability, long history of useful packages - Extensibility / customizability
- Org mode
- Ability to run in terminal mode Key bindings Extensibility, great community, independently open source, battle tested magit/org Configurability/extensibility Everything works well together. Easy to integrate the features of two completely unrelated packages. Keyboard navigation and control Its configurability, emacs provides consistency given the range of tools and languages I use with it. Extensibility and ability to test out code directly on it. Extensibility, community, free and open Extensibility, ability to configure to your needs. extensibility and the documentation Free software. everlasting. that its a lisp REPL, that you can jump to the def of any function bound to any keys, that it can run in the terminal, etc. maturity, full extension language, community It puts the means of production in the hands of the workers; in other words it is an inversion of "embrace, extend, extinguish". Extensibility, huge selection of packages and community I love the “one-interface for everything” philosophy, which is embodied by the entire emacs ecosystem (from magit, dired, org-mode to stuff like vterm) It’s been there for too long to die any time soon Huge amount of powerful built-in functions. Possibility of changing anything on the fly. Complete documentation. Coherent user interface: basically everything is a buffer/text. The possibility to perform different tasks being in the same environment. You get to be annoying to coworkers about it.
But actually, org-mode, packages, I strongly prefer emacs window/buffer management to any other tool i've tried. Helm. Simplicity Extensibility. CIDER / SLIME. One of the best things in Emacs is that it's an interactive and introspective Lisp environment that can be modified while it's running. This is quite useful when developing extensions, especially small quick functions to automate tedious tasks. I think the interactive workflow of extending the editor is quite difficult to match in other supposedly more modern editors. The rich collection of all sorts of extensions and example configuration/automation snippets that are around is also very nice thing to have. Elisp interpreting system, adoption of new technologies like LSP, tree-sitter... Extensibility, package ecosystem, stability, strong focus on community programme on pure text Non bloat. Simple user interface! Good X11 support and soon Wayland and native GTK. Good performance for the feature set and programmability. Ease of extensibility and introspection Extensibility and hackability One editor, many languages. The packages available, especially for LaTeX creation and viewing. Ability to customize it to make it MY editor. - it's written in lisp
- orgmode It's an elisp execution environment that by default executes elisp that can edit text. Customization, community, The extensibility provided by Elisp and the various packages that are written in it. Extensibility (Hackability :D). It's a running system I can manipulate, so the bar for writing a "plugin" is much lower than other editors. Configuring on-the-fly, never needing to restart the editor. Full of features, extremely configurable, Great IDE for Lisp Packages for every language. uniform text ui
self documenting Ability to write settings in lisp * the simple navigation with keybindings
* Best Clojure Repl (Cider) The elisp, many extensions and the keybinding. org-mode and how damn hackable it is Extensibility, it's amazing. the extensibility and the packages. If anything is not how you like it you can change it and make it exactly how you like it org-mode, customizable, elisp That it is (about) the same interface for all the packages. No need to learn the quirks of other stand-alone package, just the quirks of Emacs Emacs' extensibility is better than any other editor (obviously). The ability to chain together lots of events and editor commands is invaluable.
Org mode is a huge plus. Other single purpose apps try to replicate its efficiency but still don't cover everything and can't beat it's flexibility for any work style. I also love how org mode has org tangle to allow for literate programming; it has made my config so much more readable!
Magit is super smooth to use and the transient package that it helped birth has made creating porcelain for other complex CLI commands so much easier. Basic Extensibility; documentation (the fact that you can know exactly how things work, e.g. if some behaviour annoys you, you can always read this "command"'s documentation and can even read its source code); text-centric interface, everything is text so you can always mark/edit/copy/etc things -- even file names, even shell output, even grep output ... The keyboard centric text editing and the ability to build things like Magit and Elgot using elisp. What is the highest level of education you have completed?
Bachelors Masters School PhD Associates When you discover a new package that looks interesting, what do you do next?
Install and try it immediately Research alternatives wait for community wait for maturity Which version(s) of Emacs do you use?
28.2 29.0 28.1 27.2 27.1 26.3 26.1 25.2 25.3 24.3 25.1 28.0 23.1 24.5 21.4 24.1 26.2 23.2 24.2 20.0 24.4 na 26.0 Spacemacs 21.37 none my special fork 18.24 9.0 28.69 I don't use Emacs 25.0 162.0 19.3 20.1 whatever comes with the distro just my bf's 22.3 30.1 I don't know, whatever is on my repos 19.0 ? 23.0 Whatever is installed 21.12 23.141592 18.59 19.34 Do you use any selection packages?
Vertico Ivy Consult Helm No Marginalia framework default Ido Selectrum Icomplete Fido fido Orderless company fido-vertical fido-mode fido-vertical-mode Embark mct other packages require way too much cpu I think Ivy, I am not sure. anything xxxxxxxxxxxxxxxxxxxx I don't know Mostly the built-in completion UI Spacemacs trying out, but undecided Mct ?? This is a big problem of mine, I can't seem to find the One Ring to Rule Them All with completion packages. Every few years I switch because of bloat or that my .emacs has gotten so messy. Orderless (this is the key component, I could give up the rest of I had too) xsel counsel emacs 28+ improvements i can never remember I use vim I've looked into them, but not used one. fzf dabbrev which-key farts auto-complete mc Embark, Orderless icicles, if that counts Woah what, since when were there this many options. I just remember the first couple of those. Corfu Vcomplete Does "companion" count? smex Used Ido, then Ivy, now my own thing, breed between ivy and vertico default minibuffer completion I don't remember which Corfu, Company Swiper fido-vertical-mode from Icomplete Yes DOOM Icomplete-vertical (built-in) my own cursor position undo lusty-explorer useelm, and IVy, currently on Ivy. love it fussy, corfu What's a selection package? I don't understand the question. avy selectrum-prescient Considering switching to Vertico+Consult Ido was good till the vertico comes, vertico-marginalia-embark rocks raven How do you learn about new packages?
Reddit Blogs Web search engines GitHub M-x list-packages GNU ELPA/MELPA online package lists Mailing lists Discord IRC servers Matrix servers Discourse Hacker News Twitter YouTube Youtube youtube I don't friends Sacha Chua twitter Colleagues Friends HackerNews lobste.rs hacker news sacha chua emacs-china Mastodon HN Emacs China planet.emacslife.com Telegram news.ycombinator.com Fediverse epkg emacs china google hackernews telegram sachachua.com Emacs wiki Hacker news Google Hacker News (HN) Telegram chat I don’t doom Sacha Chua's Emacs news Lobste.rs I dont fediverse Emacs Wiki emacswiki.org Debian emacs wiki 4chan Planet Emacslife Sacha Chua's blog youtube videos Meetups Doom I don't use packages EmacsWiki mastodon emg Sasha Chua Google search emacswiki emacs-china.org sacha none Adoption into Emacs core Youtubers i don't Emacs News Imageboards not at all Sacha Chua's Emacs News Work YouTube videos Sacha Chua! I don't. lobsters Sacha Chua’s Emacs News StackExchange Planet Emacs N/A Slack coworkers Emacs-China i dont Emacs-china colleagues Youtube videos /g/ Sacha Chua's weekly emacs news Company slack RSS emacs.stackexchange.com YouTube tutorials/channels Colleagues; Hacker News comments I dont, really n/a null Hacker News comments I don’t, I have better things to do than following what new package is latest: I have a job to get done. My framework default is good enough. YouTube (Systemcrafters) emacs news from Sacha Chua I basically don't; haven't added anything new in years hackernews, lobste.rs Prot YouTube Still learning about old packages.... HN mentions them sometimes, as does emacs-wiki XMPP discussions 4chan /emg/ Sacha Chua's excellent Emacs news postings Content Creators Sasha chua newsletter Of course Sacha Schua, she deserved an entry here emacslife Checking other people's init.el file pacman I usually stuck with defaults :( Sascha! youtube emacs videos Onlyfans emacsconf, Xah Lee tutorials, Sacha Chua emacs news Emacs-JP community (Slack) emacs-jp Slack internet System Crafters YouTube Debian apt list elpa-* Doom Emacs Modules When I need a feature Epkgs I use vim Slack, Twitter spacemacs codebase Sacha Chua's "Emacs News" Twitter, YouTube M-x straight-use-package Sacha Chua blog Videos Various Slacks Sacha Chua's newsletter Sacha chua's blog Sacha Chua newsletter Sacha Chua Blog Sacha Chua's weekly Sacha Chua's Weekly Emacs News hn Hackernews social media, fediverse Sascha Chua's newsletter almost exclusively The emacs rocks series sacha's Emacs news Sacha Chua's weekly Emacs News Haphazard. twitter, news.ycombinator.com Sacha's newsletter irreal.org, Sachua Chua Qiita guix packages https://www.youtube.com/user/mzamansky Emacslife RSS feed System Crafters Youtube channel google, stackoverflow lobste.rs, hackernews Doom Emacs modules. Stackoverflow twitter, emacs-news https://emacs-china.org/ Sacha Chua's Emacs News (as linked from LWN.net) I don't - not keeping track I suck at discovering new packages Stack Overflow DOOM lobste.rs news.ycombinator.com freebsd forum, arch linux forum, hackernews Sasha Chua mailing list Twitter, colleagues upgrade doom-emacs Youtube, word of mouth Emacs news - Sacha Chua #emacs tag on mastodon Looking at the code of distributions like Doom Emacs Yotube channels Telegram Emacs Community Sacha Chua's weekly summary Twitter (and recently Mastodon) Sacha's emacs-news twitter, telegram I don't! Accident Debian package manager, sometimes the web YouTube, including Prot and David Wilson YouTube channels like System Crafters Colleagues, Hackernews sacha's emacs weekly post work Slack Mastodon; by chance i am still in basic-human-mode and am not really learning about new packages other than the obvious. but i reference the guide, manual and also searching for writing prose packages. People who tell me lobsters, fediverse google searchs Sacha! https://sachachua.com/blog/ and Telegram channels wishper Emacs Wiki, and on Fedi Recommendations from colleagues describe-package with vertico completions word of mouth Unsure emacsconf Do not really learn about them XMPP servers planet.emacslife.com, Sacha Chua Emacs News emacswiki (why is this not an option?) Looking at the emacs config of other users in Github i dont use emacs Planet.emacslife.com I usually don't learn about new packages ycombinator news Friends on mvp slack https://news.ycombinator.com I search my OS's binary package repo for packages to support new languages I'm picking up system crafter, Sascha Chua news I don't, maybe emacs news mentions something https://sachachua.com/blog/category/emacs-news/ I don’t really find out about new things. Would love to though I'm unaware about Emacs packages and therefore don't learn about new (or old) ones. sacha chua's weekly Generally only bother checking when a need arises archlinux.org/packages Talking to other users Planet Emacs feed telegram existis fsf Sacha Chuas awesome weekly Emacs News Friend/colleague recommendations borg Seeing other configs that do cool things! Emacs News! Jabber rooms Google it Sacha Chan's weekly Emacs newd /g/ and HN Sacha Chua's Twitter updates Video sharing platforms xmpp emacs room when I have a need for a feature I search the list of packages, or google the need word of mouth / friends A local community Slack channel emacs planet My own MELPA Atom feeds Telegram groups HN, talking to colleagues, built into doom, occasionally Twitter. I used to list-packages Web browsing Props to Sasha Chua and Planet Emacslife M-x straight-use-package recipe completion Don't My framework Hacker news (rarely) not Sacha Chau's weekly e-mail and Emacs Meetups Emacs-related mailing lists: "Emacs Devel" and "Emacs Humanities" I do not tg and emacs china Hacker News (Y Combinator) YouTube. Systemcrafters and Prot’s YT channels youtubers Emacs News (by Sacha Chua) rarely use new packages https://planet.emacslife.com/ Mastodon, other people's configs randomly youtube channels I don't really from people I follow on Twitter and Mastodon Don't use packages that don't come with emacs Following the Emacs # on Mastodon! I don't really try out new packages, but occasionally find some on github Sacha's weekly Emacs news ❤️ Emacs wiki; Guix Doom emacs curation I get into a state where I wonder if there's a package to help me do what I'm doing and then search for it. Random comments on the internet Telegram chats Don’t By accident Youtube content creators mostly youtube HackerNews, Youtube None, I don't pay attention to new packages planet emacslife Sacha Chua blog; Debian package Sacha Chua's blog in particular People discussions in emacs-china.org Spacemacs Layers Slack workspace: emacs-jp Talking to friends Emacs wiki too. I seldom look for new packages I do a web search when I have a requirement. Social media I don't care about or use new packages YouTube(SystemCrafters), https://sachachua.com/blog/emacs/ 4chan has a dedicated thread on /g/ In-house discussions colleagues, also Hacker News Emacsmirror Youtube videos and presentations None really friends and coworkers social media lwn.net's weekly links to the emacs updates Random Internet searches when I want a new feature I don't! I don't know where to get information about new packages! Doom Emacs I don't. This focus on packages surprises me a bit. I didn't know they were such a thing. Books 4chan /g/ I dont, not enough time Accidentally System Crafter Recommendation Sacha Chua's Mailing List (thanks Sacha!) Japanese community in slack Searching source and emacs git logs Aptitude new packages list Youtube, Mastodon (social media) sachachua.com/blogs sachachuah Emacs Meetups 4chan's /g/ emacs thread Emacs-China forum I always use list-packages first not actively monitoring Hacker NEws a discourse forum named emacs-china (dummy answer because this question won't let me select nothing) I have a hard time staying plugged in to the community. I'd like better ways to learn about new packages. Google search emacs AND my interest keyword debian repo Guix Sacha Chua, planet.emacslife.com (and previously planet.emacsen.org) YouTube: System Crafters ActivityPub/Mastodon Not sure MOOCs I don't learn about new packages e Xmpp Mastering emacs book Spacemacs Gitter channel I dont really go looking for new packages right now I am intentionally not seeking packages SystemCrasters Youtube channel googling Epkg hacker news discussions others .emacs.d Emacs news from Sacha Chua Youtube, like "system crafters" for example Y Combinator Hacker News emacs-news telegram groups Hn sasha chua's weekly emacs newsletter word to mouth no Dachau’s Chia’s eMacs news; searching for packages huh? elfeed Course guides when provided slack channel Google + I don't need new packages "Emacs China" forum searching for them Planet EMACS Sacha shua links tips from colleagues Youtube (system crafters mainly) People talking on twitter Youtube (system crafters is probably the biggest such channel) Distro Tube, System Crafters SystemCrafter's Youtube streams doom emacs emacs news by Sacha Chua Company chat room I check for relevant packages if I have a specific need news.ycombinator Doom Emacs Discord Googling when I need to solve a solution guix search not actively looking for that System Crafters youtube channel Often via EmacsWiki or general web search. Videos on LBRY and Youtube News.ycombinator.com Sacha Chua's Emacs News blog I don't keep up with it M-x paradox-list-packages Youtube. Especially Systemcrafters i don't? The list in Doom's config files Operating-system distribution package lists Slack channels at work depends Sacha Emacs News pairing with coworkers Mentioning in podcasts. Work Slack Sacha Chua's Emacs in a week. Don't know what a package is NEWS-file with New emacs version Emacs mailing list Hackernews, youtube emacs channels, twitter, spacemacs configs GNU Guix package list Sacha Chua's weekly news Sacha Chua’s emacs news Googling for them Various 4chan /g/ Lisp & Emacs General My framework's package list lobster.rs watching YouTube videos on emacs stackoverflow xmpp Emacswiki Emacs Weekly News Emacs News (Sasha Chua) emacs news planet.emacslife system crafters and as needed Youtube channels Google, let's be honest most people are searching "how to fix/do X in Emacs" GNU Guix package search Artix repository Sacha Chua Emacs news https://www.emacswiki.org/ Sacha Chua - Emacs Weekly SystemCrafters RSS feeds that list new packages New packages in the Debian archive RSS feeds Sacha's Weekly News My framework/starter kit's update Melpa RSS feed articles on ycombinator the emacs wiki SachaChua planetemacsen I do not use packages anymore https://sachachua.com/blog Sacha Chua's awesome blog! based on need and Google emacs-chain.org telegram emacs feeds 4chan's /g/ board telegram group https://t.me/emacs_ru guix package list, sachachua news Using web search doom emacs I have stopped learning about new packages emacs-china telegram group Documentation Orange site Rarely Twitter, especially Sacha Chua's weekly emacs news posts Telegram group Sacha's feed emacs-tw/awesome-emacs sachac Sacha Chua's weekly list lobste.rs, hn, corporate slack channel other people's public configs emacswiki, ergoemacs, etc. no, must not be answered I don't. I simply look for appropriate packages when I need one. If it ain't broke, don't try to fix it! maybe youtube describe-package search engine YouTube videos (Distrotube and System Crafters) Very rarely YT System Crafters System Crafters, Distrotube etc youtube I hardly look out for new packages Doom's init.el straight-use-package (keyword) Search engine when i find a deficient in emacs RSS feeds with elfeed Sacha Chua! Thank you! Hugs! usenet Sacha chua I am not interested in new packages PlanetEmacsLife Planet emacs Sasha Chua’s Emacs News Events emacs news by sachachua Sascha Chua’s Emacs news Hardly, randomly, google a functionality S. Chua's blog emacs-cn Friends/colleagues Sacha Chua Emacs News Collegues telegram chat not really nixpkgs i don't use third-party packages I don't learn about new packages. Colleagues and friends Sacha-Chua Emacs Weekly News How often do you contribute to packages?
Never Rarely Sometimes Often Frequently Where do you ask for help using packages?
GitHub Reddit Emacs StackExchange IRC Mailing lists Framework Discord Email Matrix Discourse I don't Telegram google Google n/a N/A I don’t none None i don't Slack I don't ask for help telegram Emacs China I don't. Friends Twitter Fediverse I dont friends web search Colleagues i dont search engine don't Web search Mastodon I do not Emacs-China Google search emacs-china.org nowhere Search Engine mastodon Don't Never have emacs china Web searches i haven't - not My friends slack Search engine /g/ search I never have DuckDuckGo Never did Internet Search the web emacs-china read the source I don't ask fediverse Jabber Never had to blogs, web pages Web Telegram groups linux.org.ru clojurians slack I haven't have not done so Gitter Search engines I figure it out myself internet haven't yet Friend Duckduckgo 4chan /g/ I usually don't never have Figure it out myself I've never needed to co-workers dont I don’t ask for help I don't know never asked for help Haven't done it Nowhere Never needed to never colleagues Search GitLab 4chan Clojurians Slack Telegram chat XMPP StackOverflow duckduckgo Work documentation no na emacswiki.org Search Engines Company slack twitter Googling i just read the documentation Google (search for help) null I have never done so Don't ask anyone. Searching information on internet and reading the sources I have never had to HackerNews I have never raised a question Web Search (Blogs, StackExchange etc.) slack (work) just search online Never done I don't tend to ask for help, I search for it instead. I find help mostly or figure it out by myself thanks to the sourcecode. EmacsWiki Emacs local community Ask a friend search the web, don't ask google until I find an answer. Look up the internet and solve for myself Never asked for help. I just don't. I probably should... Google or read source Read the documentation + source Local emacs community I have not had to ask for help It hasn't occurred in a very long time. RTFM and/or look at source code I don't, really emacs-chain.org emacs-telegram group telegram existis fsf Usually, I don't C-h f i often just do a google search dedicated emacs thread on 4chan /g/ board Googling around Local Emacs community at Slack I've never tried – Usually don't ask questions I read the package's source code Friends & Colleagues General internet search hacker news google, stackoverflow, I read source code of packages Imageboards Wherever help is the source / package documentation I don't ask, I work it out/research myself. RSE Slack I don't ask any help, just give up Coworkers Japanese Emacs community in Slack I don't. I read up on already available info if problems arise. Maintainer's choice of forge (e.g. sourcehut) Telegram chats Readme, Code Information Super-collider (WWW) duckduckgo and source code if I can't figure it out myself, then the package is too confusing to bother using never did it social media i never asked for help before. i just read manuals and search for answers in the internet I don't really ask I don't ask and try to figure it out myself. Don’t ask internet search emacschina 4chan's /g/ emacs thread Web Search I check the docs and source code Never did that Duckduckgo search. I figure it out or I move on. Never asked, only researched Reading the code YouTube tutorials Generally, I don't. ActivityPub/Mastodon I have never felt the need to do so IRL Friends Telegram emacs community However it applies to package, but I mainly search available content Read the source Usually search for others having the same issue I usually use a search engine don't know Gitlab dont ever ask, will usually give up on a package if its not working Have not done this I don't ask for help. never ask for help I read the source Google which often æeads to Stackoverflow Google it myself Clojurians Slack community Never have done so . usuakky google => emacs.SO google/duckduckgo search Google and/or manual debugging Emacs channel on work slack use search engines more intently I don't ask for help but I have found answers on Xah Lee's wiki and Stack Overflow never had to I've not needed to Have not asked for help yet. I do not use packages anymore web search engine Read the manual, search the web Friendly Lisp and Emacs Thread on 4chan.org/g/ search on the internet I don't, I can usually solve my issues through research, such as source code and other internet posts. company slack I haven't asked for help. I did not yet ask Hacker News google.com I've never asked I'm shy, i debug it myself telegram chat I never asked, if I can’t solve it reading the docs I remove it I don’t; I fix them if I care enough to do so. see above read the code Never asked for help with a package … haven't needed to yet Nowhere, generally try to figure it out by myself Source code Forum I don't use packages Google-it Japanese community on Slack I haven't needed to ask I din't I never do emg Mainly no issues so far. I'm used to finding issues on github first. Usually helps. i simply cry Stack Overflow I don't ask for help, I search the web for solutions I choose another package emacs user group at work emacswiki Haven't needed to yet. own tinkering I don't usually ask for help, but if I would, I'd try the above first. :) I never do. Slack (emacs-jp) Whatever forum the package maintainer lists in the README or similar read docs and search web Google and built in emacs help N/A, haven't had to ask thus far Just read the docs or Google I don't; I read what others have asked. /g/flet/ I don’t. I fiddle with it until it works, or abandon it See above. I don't. The community sucks and is notoriously hostile and most people _sprint_ away never done so I research and figure it out on my own. If I think there is an issue, I report that on the repo or mailing list Have never asked for help Haven't had to, mainly rely on preexisting queries tg and emacs china clojure slack YouTube Any of the above after extensive searching - most of the time my question has asked before and the answer is discoverable. Said answers are typically sourced from stackexchange or blog posts made by users of the packages. internet in general Don't. I typically don't, but would use whatever the package community appears to use. I just figure it out. Don't think I've ever asked for help - can usually get them working out of the box, or with a little googling Search first, have never ask right now. don't ask for help I don't, too shy :) Social media A frient Other Emacs users I know in real life I mostly don’t ask for help I just read the docs and the source, I never ask, only lurk. Coworker search for help on internet search engines I can't remember ever asking for help using packages I look at the source I read the source code Huh? Not needed to Do not use packages Usually find the answer with a simple google search I haven't asked Never done so e haven't done it Have never done so I don't know how to use mailing lists Mastodon, various tech groups The web. web search engines I don't do it generally, but when I do, I just use the channel that's most supported by that package's community never asked for help (yet) Google & read haven't seen the need to I don’t ask for help, if I need to ask for help, it’s too hard to use and I don’t use that package or framework I don't usually I fight my way through it or someone has already had the question answered on the web Web search engines I never did No help required. Usually the packages are rock solid and have great docs or code. web just internet search Work Slack read the docs? Google? never ask help look at source code Ask friends. I haven't had great experiences from traditional emacs support channels. Various I don't even ask for help, I would rather spend hours figuring myself the problem and if I can't I give or choose an alternative Emacs-china I have yet to do so. IDK Google to find out more I don't think I ever have Google, then give up. Web search (passive) Facebook I don't ask. Emacs-JP (Slack) Twitter, Slack telegram group https://t.me/emacs_ru Ask my friend who got me into Emacs Friends & coworkers I almost never do private work slack emacs channel I just search for information on the web I don't generally need or ask for help. I figure it out myself. I'm a loner I never ask for help. This question should not be required. I read the code and fix it I don't ask for help, but I search stackexchange, reddit, and blog posts never seems to occur to me to ask for help Events IRC was a shithole emacs-cn Wherever the package documentation directs me to google for it or give up web searches? I don't really ask for help for some reason I don't ask for help, I can mostly find the answers in documentation friend, try and error Search for help, rarely ask. I don't tend to ask for help Whatever google turns up Have not done so 4chan /emg/ Read the source code Youtube nowhere; SE or emacs-wiki generally has the answer i don't, i just search the web and the docs Googleing The source code of the package Never had to do this. Usual web search pointed me to the relevant places. wechat I use vim work teams Depends on package. Avoid rfeddit, stack overflow and other forums. Might use github issues if package github based. I switch editors html Google :'() People in my office building Usually I find out what I need to know via a search (search engine combine with one of the listed platforms) and some hands on trial and error. Have never asked for help yet Browsing existing answers uninstall package primarilly reading documentation suffer in silence emacs community inside my company ask friends Never matrix work Slack I never ask for help never, so far usenet, bitd reading docs and source code I don't, I just move on. I had to ask about one thing one time and I knew the person to ask. Wrong kind of question for me. SDF's BBOARD I mostly don't, I don't know of a good real-time and active Emacs chat Reading documents emacs-china.com Google web search I haven't needed to ask for help in a long time I usually just search for help where recommended in their readme I've never bothered google search It's own documentation and/or code i usually don't never did search the internet or talk to a friend; documentation is really great, just add some additional elisp and you get it done GitHub (unfortunately, because most of the repos are hosted there) Read the src / google / sourcegraph search for uses of it Read the sources NaN dig the internet and docs Codeberg I have not asked for help with packages. I have never interacted with others. I just research via web searches and documentation. don't ask for help (google) emacswiki, web search, documentation Work slack I don’t ask Boyfriend haven't friends and coworkers no time The FSM I haven't needed to do so yet documentation, emacs wiki, source code Japanese community in slack Internet search, and the manual (if present) manual searching on the web emacs-china tg group I didn't ask so far, figuring everything on my own, I am shy just google I don't? Twitter or Mastodon I tend to research and experiment on my own as I don't want to bother people never really bothered I rarely ask for help because someone already did and I can find an answer or clue in the Internet. Typically don’t. I usually just read the package source code and patch/rewrite things as I want. If there is a bug, I'll submit an issue. Father Local Emacs communities or meetups I usually struggle alone I look it up reading the documentation, other users experience writedowns If I need help I drop it just search I limit myself to the internet Fediverse, Twitter i don't ask I have not done so yet Emacs Read documentation, watch Youtube demonstrations Friends and colleagues Blog Hardly ask seach on the net emacs meetups, otherwise I just lurk the web learn by self i read the source code and suffer right now I am intentionally not using packages I don't remember I haven’t Google, I don't want to bother the authors too much google? I haven't had to ask for help Emacs-jp 4chan's /g/ board Searching the internet for hours On the Fediverse, usually. Telegram group NA forum search on the web My brain Package mantainer choice Slack, etc. work slack various how-to websites/articles Friends/colleagues usually find an answer through web search Never done it Typing questions and complaints into Google Search I don't ask for help unless I find a bug, there I ask the maintainers i have a codementor.io Ask to coworkers on Slack Never been necessary I never have asked directly Ask a friend who knows how to read elisp I just google it Colleagues, Clojurians Slack I never ask help Telegram channel emacs-jp Slack F2F with coworkers - or I figure it out on my own I search for the answer I don't. I read the code sometimes and I give up if I can't figure it out. We have an #emacs channel in my Slack workspace at work Edebug never happened Haven't yet Never happened so far Don't really ask, either it works or I need to read more usually I search and find an answer I just hack around it until it works Documentation or web search or No idea where to ask Whatever is available Read the manual Stackoverflow Haven't asked for help before https://emacs-china.org/ I read the documentation and/or code Not asking for help Nowhere, I read the source code First place I can I tend to work it out for myself. Documentation in emacs is fab DuckDuckGo / give up and try something else RTFM, source. don't ask, only search Na None of the above never done that I don't and use any info available and the source code more often than not Searching in a search engine i dont remember doing that Discard Colleagues/friends emacs help and devel newsgroups Doom Emacs Discord and the channels #emacs and #doom-emacs on the Clojurians Slacl Not at all I never had to Read the documentation colleagues on slack Google search. The internet... I don't, generally. Friends IRL nowhere so far i think Haven't asked for help xmpp emacs room Internet search I don't. Source code is out there. Recurse Center Zulip never asked Don’t Haven't needed to I just struggle alone. I have no idea why never needed yet Just search the internet. duck-duck-go search Last resort is to read the code. i hack until my emacs system fulfills my need local community Slack I don't ask, I just do web searches for answers. I can ask for help? I just search the web, if I can't find the answer I will just move on I never ask for help. I just comb the Interwebs and manuals until I find the solution to my problem. Yeah, I know it's weird. I have not asked for help Browse the source generally I don't I don't. I consult the documentation and the code. Don't bother Mostly do not ask for help, that's what the source and documentation is for google + pounding head on wall I don't really feel comfortable asking for help Emacs wiki, search engines Solve my problems on my own amazingly, I had no need to ask for help generally, i don't--if there's insufficient info already available, I pass on the package or dig into the code myself usually, I don't duckduckgo :) web search which leads me to any of the above GitHub, but would prefer free alternatives not required If I cannot find it with an internet search I will use the included docs and figure it out. Company chat room man and tar gitlab, source-hut Google search usually gives me what I want never had a need I usually find what I'm looking for online Don't know what a package is I read the source code and try to figure it out first. Hasn’t come up google only search on Google for answer public Jabber/XMPP room stackoverflow xmpp Not boards.4chan.org/g/ Company chat figure it out myself or abandon it stack overflow read source code I generally don’t and just search the internet instead of asking i just read the doc Documentation Give up Haven't needed I usually use only the features that I can access with the help of Internet searches Duckduckgo:) Never needed to ask. Either someone asked already, or I figured it out from the source code, or it was not worth spending time on. I rarely do Online search The package source I don't, I just figure it out or stop using the package i don't ask for help usenet I don't, either I can get it working with the docs and Google or I don't use it. Other source forges Have not asked I read the doc, then package elisp How do you manage third-party packages?
use-package package.el framework default straight manual not sure elpaca Nix guix nix leaf Guix quelpa setup.el el-get leaf.el GNU Guix borg Cask Debian nixpkgs Borg apt-get Guix package manager n/a Doom apt Spacemacs layers Debian packages doom Doom Emacs Setup.el NixOS debian packages nixos Nixos Nix package manager paradox Quelpa purcell's require-package (based on package.el) Doom Emacs as a framework try Simple custom use-package alternative pacman leaf and Eask git submodules home-manager cask Stuff packaged by my Linux distro. And a big custom .emacs I use vim doom version of straight nix module (rycees emacs-init.nix) don't use distro package manager rarely use third-party packages leaf (alt use-package) Paradox debian packaging qelpa guix packages DIY to learn really how autoloading works portage I copy the *.el files to site-lisp Portage (Gentoo package manager) el-get.el doom-emacs DOOM Using nix in practice, specifically https://github.com/nix-community/emacs-overlay guix package manager, or elpa GUIX package manager via Doom's facilities straight with leaf.el I don't Doom Emacs manage for me. packages downloaded and added in my "init.el" nix-overlay use package in the few minimalist configs i have Leaf Nix (emacsWithPackages) modify examples provided by doom Mix of git submodules and custom discovery code for optional stuff paradoxä leaf.el (and Guix and a fallback on straight) Debian package nix/guix leaf, guix guix for installing and setup.el for configuring distro provided packages apt where possible guix, setup.el I do not use them. My use-cases are very simple. Guix, Nix i dont use emacs package.el hacked by me Nixpkgs + use-package El-get Ubuntu’s elpa-* packages i don't use git, i stick with one version forever I use a git-sumodule in my dotfiles repo to manage use-package itself nix package manager My distribution's package manager track installed packages in a separate git repository idk whatever ships with emacs Using vanilla Emacs paradox.el Mostly manually Whatever doom config does, not very knowledgeable here. what ever doom uses (straight?) Nix overlay I plan to use guix install via nix