Emacs User Survey — 2022

8678 results also available as Text, CSV, TSV, JSON, SQLite DB, JLD2
Do you use an Email client in Emacs? StringNoMu4enotmuchGnusRmailWanderlustmewMH-EVMMewvmmh-eI have used Wanderlust, but gave up.I wish I could, O365 integration stops meTried Gnus, notmuch and Wanderlust. Eventually I decided that email is not a thing Emacs should handle..I have Mu4e working, attempting to transition to gnustried, but don't like the approachgnus AND notmuchNo, 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 endI used notmuch in the past, but it's too much bother to maintain a proper, working email configuration for too little gainHTML to Outlookcouldn't get it to work with Apple's IMAP... yet.Used to in the past when Thunderbird had an external editor addonUsed to use vm, loved itNot yet (but I want to)mu4e, but its configuration is awful and it is one of the most troublesome packages in my emacs configurationsmu4e, notmuchI used to use gnus. Outlook calendar integration with webex messenger made me sadly moveM-x mailI used to but not anymoregnus in the pastwanted to use mu4e, failedI use vimGnus 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.Tried but never got it to workI used to use vm mail, but I can't any more.used mu4e in the pastunder 35gnus and notmuchI don't know...MultipleI've used Gnus in the past but don't any moreTried but got frustrated and went back to thunderbirdnot yetI'd like to but haven't tried yetnot at the moment. but will in the future. Not decided client yetI'm interested in using it, but never tried itNo, but I want to get to itOccasionally because of work environmentMy own not yet publishedGnus on my windows work computer, Mu4e on my personalmutt inside ansi-termno, former gnusUsed to, but not possible due to recent 2facompose emails in emacs and send them as mailto links to other programemacs-maildirnmhI /kind of/ use both Gnus and Wanderlust but both have problems and I find myself discouraged from using them exclusively, all the timeMutt in vtermno, haven't found one which is sensible (sorry, Gnus), easy to use/configure and supports IMAPimapI used to, but it was too much of a headacheI already use a text email client which I am already hooked to, nmail, but emails in emacs look appealing too.Only as editor for muttHave not yet explored, due to lack of timeNo but used to be a heavy mu4e userUsed to use mu4ehave used Gnus but moved to muHaven't decidedfplanning on using notmuch or mu4egenerally 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 LinuxhimalayaI used to all the time, but employer email requirements made it hard/impossibleClaws - use emacs as external editorNo but I'd like tomuttI want to!
What do you think are Emacs' greatest strengths? StringExtensibilityextensibilityElisporg-modeelispOrg modeExtensibility.FlexibilityLispCustomizationCommunityExtensibility, communityOrg-modeCustomizabilityProgrammabilityPackagesconfigurabilityflexibilityEmacs Lisporg modecustomizabilitylispExtensibility and communityOrgmodeMagitExtensibility, packagesIts extensibilitymagitIt's extensibilityCustomisationExtensibleCustomisabilityIts extensibility.orgmodeAdaptabilityextensibleVersatilityOrg ModeLongevityextensibility, communityThe extensibility.The extensibilityElisp, communityextensibility, elispcommunityExtensibility, ElispDocumentationMalleabilityCustomization.Extensibility and the communityextensibility, customizabilityExtensibility, CustomizationHackabilityExtensibility with ElispExtensibility and freedomextensibility and stabilityConfigurabilityExtensibility, introspection, documentationlongevityfreeCustomizability and extensibility.Self-documentation and extensibility.Package ecosystemExtensibility and customizationIntrospection and extensibilityExtensibility and ecosystemConsistencyFlexibility/extensibilityextensibility, configurabilitypackages and extensibilityStabilityconfigurability, org-modeExtensibility, documentationStability and extensibility.Emacs lispExtensibility, elispExtensibility and discoverabilityExtensibility and maturity.MacrosORG modeExtensibility and configurabilityExtensibility and elisphackabilityCommunity and extensibilitypackages, extensibilityExtensibility!Extensibility and the package ecosystemexpandabilityExtensibility and community supportmacrosEasy extensibilityIts 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.LISPExtensibility, customizationIntegrationCustomizability.Open sourceCustomizableText editing features.Configurability and extensibilityextensibiltyExtendabilityemacs lispPackage ecosystem, extensibilityExtensibility and the community.stabilityextensibility and communityConfigurationExtensibility and customizabilityCross platformExtensibility, customizabilityelisp,extensibilityExtensibility and documentationpackagesIt's extensibility.customizationFreedomExtensibility, org-modeconfiguration/extension, packages, doesn't force me to work any particular way, runs everywhere I need it.n/aVery easy to customize to fit my workflow.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 needshighly configurablebeing extensible and community drivenVery quick even if the editing file is huge.Extensibility, big number of packages, consistent UI, serves as a poor man's tiling window managerCustomizable, extensible, dynamic (no compilation to modify emacs), extensive programming language supportthe 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 wellExtensibility & the community willing to improve things around it.Buffers and text editingIts 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 posibilitiesConsistency and extensibilityCompletion 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 wantfaster and more customizable than othersFOSS, flexibilityIn 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 platformsExtensibility, performance, flexibilitybeing 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 organizationexcellent packages, everything is textExtensibility, 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 packagesBeing so far off from the sad state of things which is nowadays' (ekhem, "modern") sotware.Extensibility and strong community.Text oriented and extendabilitySimplicity, speed, communityEmacs' 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 multitaskingorg-mode, extensible, packages, key binding, self documentThe hotkeys and number of packages, especially org-modeExtensibility within common muscle memory techniques. I don't have to throw away old habits to build new ones.Extensibility and personalizationThat it can be anything you want it to be.It’s extensibility and longevityFlexible 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 documentationit's a Lisp systemFlexibility, extensibilityExtensibility, huge package ecosystem, and Magit.Very flexible PlatformTRAMPWritten 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-documentationExtensibility + great number of packages.Flexibility/customizabilityIt'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 understandablyDocumentation, changing values on the flyextensiblity if you are comfortable with LISPExtensibility, principlesThe fact that everything appears as a buffer of text and can therefore be manipulated as such.Fully keyboard driven, extensibility, and proseThe extreme extensibilityNon-dependence of mouseExtensibility and its solid concepts of windows, buffers, frames, modes, etc.It could be configured for anything and does not require a lot of resourcesThe 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...consult/embark is the only thing keeping me from using vscodeelisp and a strong package ecosystemStability over timeorg-mode & package extensibilitymalleability. that's literally it, every other editor is better except at being emacsProgrammable 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 itselfFlexibility, hackibility, configurabilityExtensibility, uniform interface, easy interaction with external commandsIt's easy to customize and extend.lisp dynamic extensibility and the big ecosystemEmacs 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-collectionA 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 documentingExtendable and communityComplementary functionPortability, flexibility due to configurationsBeing defacto lisp editorExtreme customization and extensibility from elispExtensibiliy, orthogonality of features, proper language for extensions.Org mode Magit ExtensibilitySimple powerful features easily configured to fit how I think.Org-Mode Config as I wantEmacs 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 elispCustomizability, lispinessGood packages. Support for many languagesFlexibility. 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 packagesLack 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 experienceOrg mode, the extensibility. As a LaTeX editor it's much more efficient than anything else I've usedExtensibility and package ecosystemorg-mode, customizability/extensibility/configurability/integrability, free (libre) software, the community, its design, I can do everything without leaving EmacsBeing a GNU. Endless extensibility. Community.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 bestOrg-mode, extensibility, ability to do everything in one window, possibility to create own software withing Emacs to automise tasksIt's flexible and works on most machinesExpandability- 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 requiredIt has almost all the tools I use on a daily basis within Emacs, such as IDE, notepad, client API and more.custom defineElisp provides an incredible control over how we can extend emacs.Hackable, communityIt's the user interface of the GNU systemIt'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.familiarityextensibility in a full fledged languagepackage ecosystem, rich runtimeBuffer protocol, lisp integrationincremental searchCustomizability around editing activityExtensibility; relatively easy language to write your own package or modify existing onesfree as in free speech free as in freedomLisp environmentFlexibility, 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 everythingGood, generic conceptsFlexibility, code (core and packaged) solving lots of problems, being a central text interaction environment, communityelisp 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, trampLots of build in features. Ready to use out of the boxEVERYTHING* Flexibility * Consistency * Dynamic. Self-discoverableThe 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 marketplaceContinuityThe GUI is largely superior to what (Neo)Vim offers, which is perfect for prose and math.Extensibility, common editor for all editing needs, org-modeEcosystem of great packages.org-mode is incredibleUI, Keyboard centric and extensibilityIts extensibility and community. Plus, it's been around since forever and therefore people have had a ton of experience with it.Elisp, VCExtensibility, with a wonderful language like LISPA pleasant and helpful interface that's organic, intuitive, and highly actionable.packages and communityextensiblity- extensibility - great community - relatively fast - org-modetweakabilityDepth of editing power, super, extensibility.amazing community and packagesextensibility, customizationThere is a mode for almost any languageCustomizability, packagesIts long historyExtensibility, personalizationflexibility, customization and performanceExtensibility and org modeKeybindingsWorks 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 extensionExtensibility, completenessSelf documentability Extensibility Uniformity of the environmentIt 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 textIts rich ecosystem which supports practically any relevant (or even irrelevant) use case.Community, configurability, extensable, adapt to userYou 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 packagesExtensabilityWritten in LispExtensibility, keyboard focused editing (no need to use a mouse), magit, org-modeExtensibility and documentation. Being FOSS is a major strong point.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 customizationConsistency, extensibilityI can easily write Emacs Lisp and extended it to do what I wantKeyboard shortcuts, extensibilityOne editor for all text tasks on all platformsLots of community packagesExtensive 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/moldabilityHaving the same keybindings when writing code and plain text- extensibility - self-documentation and discoveryFlexibility and customizationThe 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 ecosystemVisibility/Editability/ExtensibilityExtensibility and the REPLExtensibility, ability to act as a universal interface for editing textExtensibility and customizability. And Org-Mode.TinkerabiltyThe 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, elispdocument navigation: once you learn a few keybindings, you can fly around your document with ease. RECTANGLES org-mode 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 languagesBeing 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 changeOpen,Free,Extendible,Immersivestability, maintenance, packagesThe 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 + customizableExtensibility 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 packagesexpected consistent behaviourVersatility. 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 packagesAbility 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-documentingComposability of the many functionsCustomizablityExtensibilty, customizabiltyextensibility and adaptabilityExtensability, magit, key mappingExtensibility, flexibility, customizability.Customizability and Control over the IDEFast, cleanAbility to write settings in lisp.The ability to alter the behavior of the editor on the fly while I'm doing my work.Feels like I can edit any corner of any option and customize to my contentIt will always be thereNot running in terminal (compared to vim). Otherwise, ecosystem and that it's free softwareelisp ecosystemEverything is text and buffers not backed by files. Makes it possible to do anything that involves text.Elisp, PackagesExtensibility, freedom, stability, community.runtime, shell, *nix tools integrated with editorProgrammability, unix integrationOrg-mode!!!Works in a terminalComplete and lightYou can run JOE instead of EmacsKeyboard shortcuts are similar to bash/zsh. No dual mode like VIMAlmost always available on remote machines.The extensibility and windowing/buffering system.Its a lisp machine!Speed, orgmode, personnalisations.Spacemacs like keybindingsCommunity and amazing packagesI like that editing shortcuts are mostly the same as in readline/bash. Selection of packages.Keyboard macrosExtremely customisableFreedom, Documentation, Community, Elisp.flexibility, stability, extensibilityHackableLisp-programmability, documentation, Org, users and developersI can type thingsIntrospection (great way to discover new commands) and many many packagesLISP 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,extensibility, org-mode, magit, macrosGood default keybindings, extensive utility through open source packages, easily tweaked to your likingNot 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 occasionIts 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 journalExtensibility in Elisp, great primitives for manipulating text and interacting with the operating system, and a community of hackers who recognize the value of thoseHackability. 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 openThe 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 likingThe 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. MacrosRun-time introspection and modificationkeybindingsCan run without any graphical interface.hackability, documentation, and long life which allows me to customize it as i see fit, without worrying it will disappearExtensibility and being a blank slateExtensibility and user controlAt 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 MagitExtensibility and powerful common packages like Magit, Org, etc.It's an integrated interactive development environmentTooling for various use casesmodesdynamc, extensibile, self-describing, open-source softwareThe 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 capabilitiesExtensibility, very broad range of build in and external packagesShortcuts and commandsfree, customizable, elispExtensibility, transparency. If I want an editor with some feature I can make emacs be that editor.Consistency accross packages, extensibility, magit and org modeextensibility availabilityIt's immense resourcefullness, in being able to tackle any problem, pertaining with text.windowingExtensibility, diverse code baseExtensibility, 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. Great design. ExtensibilityExtensibility: being able to fully understand emacs and, upon that, build the perfect editorcross platform, always available, packages for everythingEmacs 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 communityExtensibility. Emacs is a toolkit which I can shape to be exactly what I want.Ease of extensibility, great community and how reliable it isfast and robust, org-modeFlexibility Broad user community means there is special-case support for almost any odd special case I am a part ofFlexibility, open sourceComplete control over the internals and UI. It is a generalised execution environment.Extensibilty, interface orthogonality.customization and community supportExtensibiltyExtensibility, multiplatform support, Lisp-y architecture, free software, keyboard-orienting controls.Extensibility, writing, Org mode, IDE feel, image viewing (GUI)consistency, extensibilityThere'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/replDedication 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.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/CommunityExtensibility, customizability and communitylisp machine, minor modes, org-modeExtensibility 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 JoeEverything 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 elispOrg 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 lispThe 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 wayextensibility, packages for many problemsM-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 reliableDeep extensibility with a large "standard library" of functions.Programmability (incl. Macros), extensability, availability on the platforms I use.Extensiblity, documentationOne Ring to rule them all.The extensibility and the freedom to change it to my use case.e-lisp. macro. org-mode(outline mode)The ability to customize whatever I want without it feeling hacked togetherExtensibility, 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 integrationsCommunity, extensibility.Ability to evolve: pushing more functionality to packages over the years, LSP support via eglot, and the recent work on tree-sitterlongevity, customisability, extensibility, community.elisp, extensibility, cross-platform supportmalleability keyboard-centric control of UI performance wrt to Electron-based UIsBeing a live lisp machineelisp, org, magit, xommunityExtreme extensibility and vast package repository. AucTeX is a necessity for my workflow.Extensible open source and written in C which provides good performanceVersatility.Easily customizable, lightweight, simple GUI.lisp-based extensibilityConfiguration as code and extensibility. It's easy to create a specific (basic) feature for oneself.mode changeslight and extensibleThe 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 workDesire to be exploredIts 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, EasyPGconfigurability, packages (tramp, org-mode, slime, ...)Extensibility, additional packages for everything I needExtensibility and being out of the way when requiredFlexibility, community, extensibilitykey bindingseverything in one placeOrg-Mode and Roam. Backlinking notes with vim key bindings is why I use emacs every day.extensiblility with great backward compatibilityself-documentation, packages and extensibilityOrg-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 customizabilityOrgmode and dynamic elisp executionExtensibility 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, ElispIt 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 systemconfigurability and extensibility with elisp, community, variety of packages, support for many programming languages, lsp support, in-program documentationAbility 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 ubiquitousnessExtensibility, modularityFlexibility, huge package libraryHow customizable it isEfficient editing. Programming language support (highlighting, inventing, etc.), tool integration (make, tags), extensibility.Extensibility, openness, maturity, standard and consistent way of dealing with everythingExtensibility, GUI app for text scaling, variety of use cases and work flowsMalleability, org-mode and related packages (babel etc)community makes everything new work well. Completely uniform and powerful tools to work with textorg-mode is the reason I use emacs over neovimKeybindings, extensibility, customizabilityEmacs 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 LSPAbility 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 VimHow 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/cutExtensibility, self-documentation, and stability.Having a working environment for decades that has grown and changed without breakingIf you can imagine it, there's an .el for itOrg mode, packages, extensibilityShortcuts, BuffersExtensibility, 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 needLongevity, Customizability, Flexibility, Community ownershipExtensibility, 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 contributorsExtensibility 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 UIA lot of quality packagesExtensibility 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 useCustomizatoinScriptable in elisp, easy way to call commands with M-x, easy to evaluate code and read/edit/advise commandsExtensibility and platform support.Versatility, TRAMP mode, packagesFlexibility. If you know what you are doing, you can do just about anythingExtensibility, community, open-source-nessA universal interface to the computer.As configurable and extendable as can be.reliability, robustnessExtensibility 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 modifiedSpeed. Fast key bindings and wealth of commands.Its add-ons like Org-modeIt provides a consistent editing experience across multiple types of files.Macros, advanced editingIts extensibility and the surrounding community.Extensibility / ConfigurabilityExtensibility customizabilityExtensibility via packages. It keeps modernizing itself this way.Extensibility. Very well honed features.All in one, extensible, introspectable, openextensibility & text as a “first class abstraction”Strong community, easily extensiblemagit, flymake, edition through sshSpeed of adopting new workflows, independence from the big vendors.Magit and treesitterExtensibility and freedom.Orgmode, Community, dired, tramporg mode, c++ mode, etc. Extensibility and a group of experienced experts.stability over decadesrun 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, lispOrg, 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 distinctionElisp, MELPA, uniformity of experience across different modes/packagesWindow and buffer management.Ability to integrate with the OS, Org Mode, Extensible interface to function with LSP.great extensibility, keyboard focusExtensibility 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 developmentDocumentation, built-in features, extensibility.Incredible extensibility, strong integration with platform and tools, TRAMP, presenting a consistent interface across platformsFlexible keybindings, contextual menus and strong control of terminal screens.Custom & Extensibilityspeed of editingCustomisability, package ecosystem, canonical GUIExtensibility, live modifications to running environmentorg-mode, magitclean design, running on both CUI and GUI, extensibilityCommunity and performanceExtensibility, self-documenting, lisp basedConfigurability 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, ShortcutsFreedom. 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.programmabilityEthics, extensibility, package ecosystem, stability, documentationSimplicity, great range of actions, communityExtensibility and adaptationHigh quality packagesvery customizable, works exactly the way I want it toorg mode; community;Describe something, change something.Introspection powered extensibility with LispExtensibility/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 magitThat 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 editororg-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 communityExtensibility, 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 transparencyUsing 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.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 ecosystemExtensibility; 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 effectIt'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 - customizabilityCommunity, ExtensibilityIntegration with various ecosystemsIt works and you can expand your knowledgeThings 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 packagesOrg mode. Evil mode. Dired.Complete flexibility for the user experience, powerful built in extension languageCan do everything.Easy extensibility and customizability. No-mouse usage. Can be lightweight, if needed.It works in terminal.Flexibility, extensibility, lispThere 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 softwareThe customization ceiling is really highextensibility, introspectionExtensibility 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 modeLack 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 Packages CommunityOnline documentationThe ability to modify and run packages without reloading the whole editorExtensibility 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, configurabilityIt is a fully featured Lisp IDEExtensibility, longevity leading to many packagesBeing a Lisp interpreterIntrospectability Extensibility org-modeSupport for diverse present and future domains and composability with external toolsElisp, 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 waysThe 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.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 functionalityextensibility and Lisp interactionExtensibility and customizability as well as community culture that promotes writing packages that are oriented towards customizingarchitectureMultiple buffers. Never have to use a mouse. Speed of development.extensibility, configurability (due to breadth of packages available)extensibility, discoverability and lispIt will live for a long time and nobody is telling me what I can and can not do with EmacsExtensibility -- most importantly, the interoperability between its extensions (e.g. automatically connecting email/scheduling to org-mode)Working with Keyboard, org-modeConsistent interface across platforms and across releases. Turing-complete extension language.Keyboard Macroselisp, not unix stuffMacros, Extensibility, Available PackagesSpeed of operation and useStability and extensibilityGuiTotal programmabilityCustomisation, self-documentation, freedomExtensibility. Chording. Breadth of commands -- so many commands immediately available.The emacs-lisp interpreterextensibility, simplicity, durabilityMany Built-in features that make you live in the editor regardless of the os in useStability, extensibility, org-mode and the ability to use vim bindingsversatilityEasy to configure, also Lisp- Lightweight out of the box but lots of 3rd party packages for additional functionality - good initial key bindingsgreat customizing by elisp. great krybindings.Programmable, and highly consistent experienceExtensibility and portabilitytext editing capabilitiesExtensibility, its open natureIncredible flexibility; and the fact Emacs is community-driven project, it's not depend on single company or mantainerextensibility, customization, been there for a long timecan do anythingThe large amount of built-in function (e.g M-x butterfly)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)all in oneExtensibility and orgmodeThat 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 windowOrg roam, packagesExtensibility using a language that is little less esoteric than vimscript.extend-abilityOrg mode, note taking, easy capture and integration into programming/thinking workflow.flexibility and all the packagesExtensibility, 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 wayI 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.extendabilityOrg-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 bindingsStability, 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 toolsConfigurability.Extensibility, simplicity (compared to say Visual Studio or VS Code), stabilityCultural values.It has consistently gotten better over time.You can use Emacs for many thing including coding LOLPowerful text-editing features Extensible, with a mode or package for nearly everything I encounter (new) Dired Editing files remotely (via tramp)Lisp REPL, extensibilityModularity, aim to roll your own distro1. 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 modeThe extensions: magit and org-mode were life-changingCostumization, elisp, org-mode, magitExtensibility and customizability, macros, buffers for running shellsThe community that continues to improve itOrg mode Packages ExtensibilityI’m mostly here for Doom emacs’ curated packages & configergonomicThe Lisp RuntimeThere's always an existing option for anything.Extensibility, org-mode, keybindingsFor 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 vimPowerful prose editing, good exporting, customisability for diary-keeping, work-tracking, etc.By far, it's configurable and extensibilitypackages! 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 LispEmacs 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, inspectabilityORG MODE. I love org mode so much. Extensibility. Stability. Packages.1. flexibility 2. extremely well documented 3. org-modeorg-mode, slime, packages, extensilbiltyEverything 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 elementsone-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,extensionsSpeed, tooling (magit, projectile, lsp-mode), offline useWell-structured config, TRAMP, byte-compiled configAPI 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 packagesI 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. - Customizability. - Source code availability. - Portability. - 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 workHistory HackabilityExtensibility, paradigm consistency (it's just a bunch of buffers)Vim keybindings, great packages, customizationBetter customizability and org-mode + org-agendaExtensibility, Org mode, EXWMspeed, availability, configurability, freedomExtensibility, 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 communitypackages, tramp modeExtensibility, 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 mouseIt is convenient to write function to simplify my workflowThe programming environment.living in emacs (org-mode, calendar, mu4e)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; expandabilityBeing 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).You can replace or extend any behavior to fit your need.The wide number of available packages for every little thing.documentationAll, 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 neededIt is an integrated computing environmentTruly 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. extensibilityIt'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 turtleseverything is text filesExtensibility/programmability; M-x shell; org; built in modes; operating in terminal; completing read; magitIt's extendability and customizabilityFreedom, customizability.Longevity and customizabilityevil-mode, emacs-lisp, daemon/client, emacs-mode(without evil-mode), eshellSupport 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 includedBoth its extensibility and its self-documentationits extensibility combined with its communityIts extensibility with the power of Lisp.Extensibility, packages, community.Everything can be done in the editor, don't need to use a mouseExtensibility and the community and its packages.Totally introspectable and extensibleOrg mode, magitDepth, extensibility, documentationConsistent text manipulation combined with so many packages and contexts to use those commands.Extensibility ,OrgMode, Communitydiscoverability, extensibilityThat 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.OpensourceIt's modularity and extensibility to the users disposalcommunity, flexibilityOrthogonal my apply concepts. Everything being buffers. Possibility of nested usage of customisations.It's not vimExtensibility, high-quality packages, ability to work inside a terminalMalleability! 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 ecosystemTerminal (over ssh), Org mode, Customization.Great suite of packages, extensible and fast. MagitEverything 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-modepackage ecosystem, lisp evaluationextensible, stabilityCross platform, configurable, extensible, widely supported by packages, fast, native, LispIt 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 extensibilityEmacs 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 reallyI 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, etcFlexibility and extensibility. Great builtin tools like org, occur, dired, ediff calc.Extensibility. Shell-mode/comint-modeAuctex, LaTeX support, LaTeXBeing free and open source software, stability, interconnectedness of all the different partsorg-mode, it made me fall in love with writing.- Hackability and transparency (open hood). Effective and practical software freedom. - Ability to reuse Emacs skills for many tasksOrg mode, extensible.all the things you can do with it - awesome and it never gets in your wayBuffer and lsp nowLisp, customizability, communityEmacs 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 terminalExtensibility and Orgmoving around text with keys and bulk editingIts 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-havesThat it is extensible in a reasonable language - elisp is much easier to work with than vimscript.Extensibility, configuration language is language used for writing packagesEasily hackable.Adaptability and consistent cross-platform use.AucTex Org mode Flexibility1) 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 contextsExtensibility Packages Org!!!Keybinding system which combine chords and sequences and allow us to use all features without mouse which is amazing for laptop on lapDiredpackages, ecosystem, cross platform + terminalGUI: 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 documentationextensibility and consistent behaviour, interactive helpThe unparalleled extensibility, packages and customizationI 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, OrgElisp, Server/client mode, packagesPortable configuration, extensibility, mouse-less keybindingsEverything can be changed to your liking.Amazing packagesExtensibility, endless customizationIt's a lisp machine built into an editor.flexibility and textual user interfaceLisp 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 everythingelisp - extensibilityExtensibility, availability, customizabilityExtensibility, and keyboard driven editing.I can perzonalize itExtensibility, 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 performantIts 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, IntegrationExtensibility through plugins - magit, org, etc...Being an customizable, extensible super-app for the Desktop aligned to user interestsElisp, dedicated developers working to improve itGrowing with the user over time and discoverability.Libre Extensibility & CustomizationFreedom and programmability.It worksExtensibility, discoverability, communityThe 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, CommunityPersonnalisation, extensibilityFlexibility// ability to integrate it with pretty much anythingExtensibility? 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 - community - 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 functionalitykeyboard macrosediting, magit, terminal mode, trampBuilt 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 lispExtensibility, LISPDedicated community, great packages, portability and configurabilityEfficiency, minimalism, control.Extensible, free software, lisp machine.1. Can use TUI in a SSH session 2. magitmy favorite thing about emacs is org-modeExtensibility, being able to look directe at the source of each called functionThe 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-modeExtensible, customizableExtensibility and configurability of said extensionsLongevity/resilience. On-the-fly extensibility.Extensibility, configurability and compatibilityAside 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 psychotherapyExtensibility, 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 environmentextensibility, it's license, magit.being able to write my own functions and modes, consistency over many modes/applicationsIt 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.It is a uniform interface to a large variety of applications.easy to extend.Extensibility, lightweightness, ELispNote 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 packagesOrg 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 environmentIt's customization potentialnative 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 flexibilitylisp interaction mode for easy calculationExtensibility, flexibility, portabilityCompletely 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.Packages Extensibility CustomizabilityFeaturefullnessOrg mode Its extensibility"everything is text" interfaceExtensibility and Ecosystem, org-mode + org-roamOrgMode.magit, org modeCustomizability, extensability, existing elisp applications and packages.High quality code base.Extension ecosystem, editing experience that works the same on any OS, FOSSIts 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 idiomsYesmajor 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 packagesIntegration of text manipulation across e-mail, PIM, programming...letting you create a complete programming environment - akin to an IDE, but much more customizableExtensibility 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 aroundKeyboard macros - main reason used for many years - now useful packagesCustomizability, reliability, lots of good packages/modes included in vanilla distribution.Packages, extensibility, community, keyboard movement.Self documenting Elisp - extensibilityOrg-mode FlexibleDocumentation, programmability. Package support for many languages and tasksExtensibility, 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 LispOrg-Mode and the plethora of other packages.Extensibility, Keybindings, Package Quality, Org-Mode, MagitIts 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 documentationExtensibility, lisp as configuration languageExtensibility, community, managing somehow to stay up to date and relevant in the age of vscode, magit, org modeCoherence and longevityGlobal state (also it's greatest weakness). Ability to patch the world from your running instance and move on with your life, instantly.The ability to do multiple things with a unified keylayout and all programmed in elisp.Amazing set of packages. Vanilla emacs is snappyIt 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 packagesCustomizability, universality (generally good editor for different purposes), keyboard-orientedbuilt-in functions and kbd macrosThat 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 packagesWidespread async support.Commuity, malleability, powerful featuresIt was definitely the best text editor I have ever used.It's keyboard center of focusIts powerful text editing features from a command line.Customizability, extendability, community, self-documentability, FOSSThe 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 freedomAlmost entirely mode free editing, Extendability, Chording > ModesextensabilityEverything 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/graphicalflexibility, programmabilityCustomization. FeaturesUsing 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 supportIt 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, extensibilitySelf-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 systemIt's fast and extremely composable. Knowledge learnt in one context is almost always applicable in other contexts too.Free, open source, extensibleworks great in both GUI and console mode, and elispInfinite 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, communityResilience — 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, UnbloatedI’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 resourcesExtensibility : it is the closest thing to a Lisp Machine.community packagesThe extensibility and the community, and it's open-source.terminal / daemon + low memory footprintIt's like vim++ with doomCommunity!org mode; it is a revelationsimplicity. 'all is there'.Extensibility. I like that it's a lightweight Lisp Machine.introspectability and extensibilityExtensibility via emacs-lisp; robust package library; stability (as in: emacs doesn't crash).It’s project management featuresIt'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.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 packagesThe ability to customise it to do the most complex tasks whilst within the bounds of the tool that I use for other thingsConsistent key bindings, usable without mouse. Org-modeExtensibility, Elisp (especially for the interactivity it provides)Configurable, features, OS agnosticThe 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 - Magit - Be able to create temporary buffers whenever you want - Consistent keybindings across different uses inside the editorExtensibility : many great packages (notably magit, org), and vim editing styleThe 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/customizationExtensibility and keyboard driven.Extensive set of key bindings, vast number of very good internal & external packages, simple to extend ad adapt to one's needsEfficiency, extensibility and portability.Extensibility. Optimal mix of UI and text editing capabilities. Packages such as org-mode.Customizability/extensibilityAvailability and extensibilityA big library of extensions; scriptable text manipulationEmacs 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 interfaceConsistency over many years. Support for all sorts of things you might want to do with it.Packages. Nice community.Maggitits extensibility but for me apart from some python programming org is the only reason for emacs use.many packagesConsistent 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.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)The potential for working at the speed of thought.Change what you dislikebeing able to do anything, very well, fastMagit.EIN, eshellOrg mode, Extensibility with Elisp and Elisp development evironmentExtensibility, 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_ configurationSupport for multiple languages, extensibility, keyboard driven control, terminal supportMagit (the greatest piece of software ever written, IMO), extensibility, communityLifetime 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 buffersFOSS, configurability, community for default configuration and packages, second brain, predictableMatching terminal and graphical user interface. Elisp.extensibility, stabilityQuality. GPL3+. Moderate but rewarding learning curve that keeps the IDE hoppers out.extensibility, community, quality, maturityThe package ecosystem with support for everything under the sun, and the flexibility of running on the terminal.Customizable Org+org roam+org agenda+org babelKeyboard orientation, packages like org-mode, org-roam, magit.full customizabilityCommunity + extensibilityThe C- and M- usage. There are no editing mode like in vim. Also it has many packages. Good integration with hunspell. Great for LispOrg mode. Magit. Major and minor modes as a concept. One editor for everything. No changing and relearning new bindings.Continuing dedication of the communityProgrammability - 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 pluginsmagit, avy-modeExtensibility. 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 ElispGraphicsintegrated UI.customizable compatibility Org-modeLongevity. 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 performanceEvery 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.orggood extension language, good set of extensions (dired etc), good set of text-related primitivesExtensibility, especially the ability to change/advise any functioninnate lisp-based extensibilityExtensibility 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, cultureorg-mode, hackabilityExtendibility and flexibility.Its overall ecosystem: elisp code and OS usageProbably extensibilityExtremely 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 languageLisp and runtime programmability. Mature ecosystem. Keyboard driven.Meta-SlashExtensibility Outlast me Open source Making your editor your own power toolthat 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 oneElisp 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 EVERYTHINGA large library of pre-existing packagesExtensiblity, its documentation, stability, robustnessExtensibility 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, extensibilitySelf-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 systemExtensibility. 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 ecosystemBetter syntax highlighting than vim. Org-agenda Notmuch General extensibilitySpeed of use, keyboard only possibility.Killer plugins. org-mode, magit, etc.flexibility; custom behavior fairly easy to implementFast 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 reliabilityThe 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, freedomEmacs is a platform for LISP programs--an ecosystem, not an editor.High efficiency ceiling, configurability, many useful packages, centralisation & unification/co-usage of many functionalitiesExtensibility 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 documentationit's not very opinionated and can be tailored to my needs better than other editorsExtensibility and community-basedRich ecosystem integrationMagit, org-mode, composabilityBased on text and standards It encourages extensibility Respects all freedoms Teaches me better ways of doing thingsUltimate 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 extensabilityOrg-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 simplicityThe 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 EmacsEcosystem and extensibility, and a rich GUI interface compared to vimExtensibility. I can tie it into any workflowThe package ecosystem and the modular natureHackability, configurability, remote editing, packagesOnline help, stability, and portability.Elisp! I love the fact I can modify right about anything.ability to easily customise and adapt to suit individual needsCustomizable 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 communitySelf documenting, Extensibility, Light Weight.Its freedom and extensibility1) Macros: any repetitive thing I can just turn into a macro 2) Being able to write functions and modify existing onesOrg mode, Slime and evil. Its vim with a very good note system and debuggerExtensible 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 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 switchExtensibility. Configuration, macros and extensions as a same thing basically. And Magit.Emacspeak, intensibility, packagesExtreme customisability, extensibility, combined with backwards compatibility.Extensibility, documentation, ability to avoid using the mouseProgrammability, malleability, Emacs LispExtensibility, org-mode, and focus on user-freedoms.The design behind major and minor modesportability, lean GUI, remote editing features, orgmodeEverything can be configured.Very powerful commands for text manipulation that are easily available and searchable via M-xExtensibility, 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 packagesExtensibility, lsp, orgmode, communityEmacs 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 approachExtensibility, ease of uses. Speed, and that its all textHighly Extensible, top notch feature setAmazing 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 softwarePlasticityOpen source and customizableKeyboard-first buffer switchingOne 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 whyExtensibility and lisp The extension language being lisp is a synergyThe 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 wantextensible, macrosKeyboard driven ExtensibleWhen 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, extensibilityExtensibility, ability to run in terminal/text-only modeThe 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 releasePackages for everything As minimal as I wantExtensions, open source, not from Microsoft, text editing capabilitiesExtensibility 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 No telemetry FOSSI 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 useThe ability to innovateIts 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, hackabilityExtensibility, customization, small memory footprint compared to equivalent GUI apps for email etc.Inspectability and self-documentation helps users learn to tweak things.It's FOSSAdaptability and (if this is a word) ScriptabilityExtensibility 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 scriptsIt's a transparent system, based on LISPIts 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 lowThe 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 environmentExtensibility, buffers and magitUnparalleled extensibility and capabilities.easier to configure than vimExtensibility/customization. I can rig up functions to do anything or find a package to do it for me.magit, diredThe customization and extensibility. I also appreciate the ideas of the FSF but I wouldn't say I am a die hard believerconfigurability (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 editorEmacs 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-lispExtensibility, consistent UI metaphorsAn 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 LispEase of understanding, good documentationCustomizable, 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 propositionExtensibility 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 monopolistit is quite extensible and customizable.Core + everyrhing else in LiSPBuilt in documentation. The architecture enables project management.extensibility, self-referencing, inline documentationExtensibility/programmbilityorg mode, flexibility as an IDEExtensions, Elisp, community, a platform for all things about textWide library of community codeExtendability because of elisp可以完全使用键盘操控Magit ExtensibilityThe 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, customizationextensibility through elisp; communityExtensibility and eco systemIntegration of environments without the sluggishness of other IDEsThe 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 flyOpen 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 changedextensibility and existing/new packages via that extensibilityExtensibility and key bindings.Extensibility, depthON THE FLY Extensibility. Self documentationExtensibility! 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-modeOrg-mode. Extensibility. Packageselisp. 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, OrgExtensibility and how customizable it is. Also the fact that Emacs is essentially a Lisp machine.Extensibility and changing its behavior at run-timeFlexibility, speed, power, upgradability- extensibility - explorability - documentation - maturity - free softwareExtensibility, GUI slateCommunity, and being a GUI interface to Unix toolsIt'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 resultsAbility 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 easilyelisp and flexibilityExtensibility, and ease of use once learnedNo nonsense by choicedetailed editing commands (e.g. swapping words, rectangle edit)Extensibility and providing a unified interface to many tools.Extensibility, Org-mode, Magit, LSPThat you can use it not only as a text editorOrg Mode and Literate Programming, Major Modesextensibility, making an editor completely my own.extensibility, there's a command/package for everything I need & then more portableEasy to adapt to my workflowThe 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, magitExtensibility and community packagesCustomisations. Org. Pdf-tools. Mu4e. Eglot.It's close to a Lisp machinelisp, packagesCommunity, Extensibility, Multi-Platform, works in terminalRMS being controversial.It's customizabilityConsistency, speed, memory usage, extensibilityELISP, Package management (melpa specifically), availability for different platformsCore 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 sshExtensibility and keybinding for everythingFlexibility and customizabilityExtensibility, discoverability and the self-hosted development environment.code design and editingRich text supportextensibility and community!Extensibility and being able to edit anything within emacs from itself. The reply/smalltalk like nature of it.Keyboard bindingIt's an operating system so it can does everything. The sole limit is the imagination.Powerful functionswindow/buffers over 1200baud modem. Emacs scales, week machine toss out LSP and big configs.- Freedom - Extensibility - Community - One software to rule them all / Integrationspeed.Connection to replExtensibility, packages, communityExtensibility, documentation, packages.It can do anything with enough tweakingELisp, libre source, cross-platformDiscoverability, programmability, freeEmacs is extremely customizable, and relatively simply so.Complete control and extensibility.One editor to do everything I want to do in terms of programmingReliability, customization, range of use casesExtensibility, 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 uniqueExtensibility, open-source, org-modecommunity and it's fun to useOrg mode, control over layout, self-describing packages, community and extensibilityExtensibility and flexibilityExtensibility (lsp/eglot) one ide to support many different languages with minimum configurations (melpa), while having the same core editor experiencesExtensibility, TweakingI love using org-mode for journal and org-mode + org babel for creating executable documentation.Transparency and robustElisp, org-modeorg-mode ;-)Customizability, Programmability, Graphical User Interface SupportExtensibility, CommunityWhatever 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 featuresIts 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 emacsConfigurabiltyLongevity, license, self-documentationIt's free and has great support of Clojureelisp and hightly extensibility packagesThe 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 existenceLongevity 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 optionsIts an Lisp machine that provides an integrated computing experienceIt'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, calcCommunity, and evil keybindings for those coming from vimExtensibility, 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 packagesExtensibility. Light weight. Fast.the mesh of data (text) and code (elisp) - almost like reflective programming, its extensibilityTrustworthiness: 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 onOrg-mode export PackagesVery 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 toolsExtensibility, Community, and Freedom.I'm somewhat familiar with it.elisp org mode magitAdaptability and long-term usabilityBeing 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 togetherExtensibility, 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, ubiquityFast 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 everythingIts unwavering dedication to its niche, which attracts like minded and capable peopleIt makes complex actions easy to do. I love its macros. I can do everything inside it - no context switching needed.Packages / org-mode / trampI 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; communityextensibility, community, customizability, the usual keywords.Extensibility, magit, org-mode확장성Its extensibility and modifiabilityThat 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).Able to use vim keybinds lolconfigurableFree forever and its extensibilityI don't need a mouse I can make it do whatever I wantit's transparent, easy to modify, it's free softwareLong term stabilityextensibility and customizationSimple C-based core ElispThat 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 shortcutsBeing the closest to a Lisp Machine that I'll ever use.KeybindsInfinite extensibility/customisability, open source,ELispI 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 automatedMulti Platform, Packages / ModesLongevity, Community, ExtensibilityCommand discoverability Versatility Buffers and windowsBatteries 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 hackabilityWhat 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; configurationrectangular operations, integration with GDB, keyboard macros, dired, shellFlexibility.Extensibility through a full programming languageUbiquitous, can run in a terminal yet allow sophisticated editing.Extensibility and modifying default behavior without maintaining a forkKey bindings (customizable).Configurability, packages environment, programmability, Org-modeNative GUI Org Mode ModularityExtensibility, ecosystem and the greatest: I can rewrite the editor at runtimePackages, 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 * elispplugins and easy scriptextensibility, rich text in GUI (compared to vim)Extensibility and built in documentation for functions and variablesThe 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 codebaseText editing capabilities ExtensibilityEmacs'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 OSLisp-backed, interactivity, self-documenting natureI 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 ecosystemGNU, opensource, cross platform, no bloat, no nonsense, extensible, packages,Run-time configuration, self-documentation, explorability, large community.Customizability, keyboard based interfaceExtensibility, 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 Vibrant community Free to use and modify without being backed by a profit-driven organisationAmazing community tools like org-mode and magit.Keyboard Macros, extensibilityModelessnessEmacs 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 integrationsIt’s everywhere and it works. And org mode. Definitely org-mode!Being mostly written in elisp, configurability.Text-editingProgramabilityextensible, sustainableLisp!It's much more than a tool as it is designed to be hacked, so it's a hacking school itselfThe 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. :-DStrong community-driven package ecosystem; org-modeElisp extensibility. Community.performance and easily extendableThe built in documentationOrg-mode, extensibilityIt's sooooo fast, and versatileFull 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 ecosystemEditor 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 freedomEvil Mode and LispIt'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 bufferExtensibility, 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 ElispThe 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 softwareCustomisability, High quality packages, Integration of various packages- Unix philosophy - Speed - ConfigurabilityBeing 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)liteExtensibility and/or customizabilityIt 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.keeping my fingers on the keys, extensibility, themingExtendability and way how it integrates different workflows into unified way.ability to use the same editor in the terminal and guiextensibility, magit, org-modeCustomizable, Extendable, Keyboard-focused, great packagesExtensibility and how everything I do is in a bufferExtensibility. 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* Efficient keyboard-based navigation * Efficient use of screen real estate * ExtensibilityReusable 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 everythingExtensibility, 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 eternityCross platform, including command line. There is a mode for every language. I LOVE org mode.Open source, great packages, flexibility, lisp configuration languageReadable, structured customization of basic editing, and the well-developed modes (C, org).Extensibility in Emacs Lisp and Org modeEmacs 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 communityWhile 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 itPackage ecosystem and maturityHow much the Emacs care about backward compatibility. Plus, how powerful and simple the system to extend Emacs is.Extensible with a variety of packagesextensibility and bindings to the underlying operating systemElisp.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 IntrospectionORG mode, Infinite extensibilityFlexibility, 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, configurabilityLarge community with a package for everythingCommunity of contributorsIts modularity, its adaptability and its community.When it does work, it works perfectly.Extensibility and LispThe 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 accessibilityorg mode, diredThat 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 keymapsMagit, org-mode, malleability is nicewell- and self-documented; active community; extensible; it becomes natural to want to do everything in emacsKey bindings, runs everywhereTransparency: 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 flexibleText editing, extensibility, works in a terminal.Packages, extensibility.It can be adapted for any purpose -- and someone has already created a package for thatIt'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 Emacsextensibility & malleabilityEmacs Lisp is highly extensible and can do anything that the OS can do.The community and the extensibilityThe fact that you can customize anything.Lisp machine, extensibility, free/libre software, self-documentedMultiple Windows, keybindings, elispcustomizability, documentationmagit, 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 greatOrg 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 extensibleKeyboard-driven, org-mode, magitMagit, a proper extension languageBeing a LISP machine, great ability to adapt to everyone need. Free (as Free Software).Configurability, elisp, org mode, magitLisp machine conceptHigh 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, distrosPredictabilityCustomization, fully customizable by code, extensible, every problem has a solution. Overall it feels consistentThe simplicity and extensibilityExtremely customizable with Elisp.extensible programming environmentThe 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 packagesStability, rich package systemBeing 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 LispCursor movement without lifting my hands from the keyboard, extensibilityBuiltin packagesHelp system with finding functions, keybinds, documentationIt'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 packageselisp 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 languageThat it can do everything you want it to, and it runs everywhere as well, on about any hardwarefully customizeThe packages, the customizability, the communityit's more of an operating environment than a text editor.ESSCustomization, extensibility, packages, org-mode.Configurability with LispGood 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 learnabilityCustomizing the editor by writing programs. The fact that everything is a text.Extensibility and introspect-abilityYou can make it do anything you want; complete freedomFor me, it's all about how you can make emacs your own.Built-in documentation, integrated environment (code, org-mode, calc, shell)built on lispExtensibility. It can do or be anything you want it to.Easily hackableThe 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 sooncan be easily extendedBeing able to reach in to any internal and read/modify/understand how it works. Package ecosystem, the full functionality of org modeExtension and long term usageIt can handle a wide breadth of languages, and the keybindings are complete muscle memory at this point.Elisp, extensibility, large ecosystem of pluginsexisting packages & ability to modify the interface / text however you see fitOne text editing experience across many different tasks, and Magithaving easy to use modes for doing almost anythingProgrammability 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 everythingextensibility, lisp machineUnmatched 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, extensibilityorg-mode, better than Vim IDE features but still good Vi-style key bindingsGUIExtendability, longegevityartist modeIt's cool. Extensibilty. Customizability.community especially the ones maintaining large distributions and packages such as doom-emacs / magit / org-mode and major modesExtensibility, 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 Extensibility Quality Packages from communitySelf documenting nature. Magit and org.Extensibility, configuration, TRAMPMagit and other great packages. Infinite customizability.open source and free software, extensibilitiesPackages and built in features like gdb clientEvil mode and org modeThe 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.elthe history, the buffer concept and the community.40+ years of development and solid package development communityExtensibility through external packagesExtensibility, and that it's FOSS.- we can program Emacs the way we want - documentation is included - Emacs configuration, functions, etc can be inspectedExtreme flexibility + Lispkeyboard navigation, predictability, customization.Modularity, flexibility, and making your tool suit your trade.Extensibility through elisp.Powerful packages such as CIDER.Useful package ecosystem, extensibilitySupport for code placeholdersIts extensible, and it is pretty discoverableCrazy 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 communityAdaptability, extensibilityLisp! Modularity!Plugin Quality, Org Mode, workspaces, magit, execution of commandsExtensibility, Flexibility, and long term support. It's a lifetime editorSpacemacs default packages+ clojure layerdynamic 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, LibreExtensibility, moldabilityThe 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.elPortability, extensibility & malleabilityElisp, Everything is a buffer (orthogonality), you can add any functionality very easily (that is impossible even to imagine elsewhere), keyboard bindings and their extensibilityIntegration 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 timeopen source, works in terminal and gui, extensible, configurableEndless extensibility, Org mode, active and creative communityExtensibility, Org Mode, Flexibility, Elisp configurationExtensibility, programmability (automation of common tasks), org-mode ecosystem, magitIts community and extensibilitycustomizableIt'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 familyIt fits my needs through many available packages and its extensibilityFlexibility and user empowermentKeyboard focused, no need for mouse. No Gui necessary. Extensibility.Extensibility, visibility of current state.source code available, good documentation, elisp, and ongoing improvement of elispIts extensibility and how customisable it is(E)lispAbility 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-keyExtensibility. It feels like a tool that I can adapt to me, instead of having myself adapt to it.Customization, extensibilityAmazing packages, programmability, LISP, text based interfaceExistentiabillityVast 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)Freedom and extensibility- Plain text - Faces customization (font, color, size). - org-mode utilities: Todo, Agenda, Calfw-calendar, internal links1. Extensibility and a good package system (after Melpa came into being) 2. Large userbase of developers 3. Integration with Unix like OSesOrg Mode, Magit, LSP, VimEasy 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-documentingThe 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 packagessmart editorExtensibility 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 GPLEmacs 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 absentlibre, 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 * Extensibility * Elisp * orgmode * magitFreedom and controloverall consistency over time, availability across platforms, ability to accommodate a wide range of usage patterns (with notable issues)AucTeXExtensibility. 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-freeBackward compatible is taken very seriously.extensiblity, elisp, rich featurea 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 itGood text rending, neat UI, very extensibleCustomizability and free and opensourceYou can make it whatever you want it to be, everything and anything can be turned on and offCustomization, 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.adaptabilitytrusta lot of capabilitiesExtensibility for me is Emacs' greatest strength, also the awesome community.Extensibility, Lisp, CommunitySLIME and extensibilityExtendability, keyboard only interfaceMagit Vterm The fact that everything is just text buffers that you can use your existing editing commands on.Open source, extensibility, communityEmacs 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 environmentStability coupled with almost infinite extensibilityHackability based on Lisp extensibility.Keybindings, org modeeverything is a buffer. Very discoverable. Good documentation.Full lisp environmentSome great packages like Magit, org-mode and CIDERextensibility 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 freedomSame 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 packagesCommunity, packages, extensibility, free softwareThe promise of being able to create a minimal set up that works for many languagesBeing able to simply and easily compose multiple, complex packages together to create custom workflowsExtensibility, Key bindings and its customizability.The level of customization in combination with years of written packagesextensibility, programmabilityOrg mode Discoverable key bindingsThe extensibility where I can, even though most of the time I haven't, further customize it towards my needs.Extensibility, uniform UI for different tasksEasily looking up function definitions, variables, org-mode.Extensibility, Lisp-machine, well-integration with OS, self-documenting, text-oriented, stableElisp 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, elispadvanced, extensible, customizable, self-documentingCan survive with minimal tweaking and defaults.Runtime for to create TUIsPrinciples of the GNU project, extensibility, lisp, ecosystemUnified interface, easily extensible, excellent community.Simplicity and complexity at onceOpen, dynamic, historyCustomizability, extendabilityFreedom, 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 tasksIts extensibility and the simplicity of its programming modelMagit Its community of active users.Gpl, packages, extensibilityYou add the functions you need and can change how they work.Packages, magit and org mode. Great ecosystem and doom gives great defaultsCommunity, FOSSExtensibility, Querying functions,vats,state.Extensibility, consistency, simplicity, LispExtensibility, without a doubt.Extensibility. Lisp Machine.The extensibility, package ecosystem, and text manipulation/interfacing.Org-mode, infinite extensibilityI can do a lot of things with just a few keyboard strokes.customizability and packages that can fully change behaviourExtensibility, eco systemExtensibility and internal documentationI can configure it to do much of what I want through readily available packages.Portable, long lasting, actively maintainedProgrammability, cross platformEverything that comes built in, like the image viewer, dired, etc.Customizability range of packages tons of featuresBeing 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-modeM-x, C-h k, 'defunSpeed, customisability, fewer distractionsself-documentation, extensive documentation, extensibility, all the packages already written for itExtensibility, 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 packagesUniversality. You can use it for everything.Readline, Customization, HistoryTerminal supportIt’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, ediffBattle-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 languageCombined power of extensions on a custom local and remote IDE.Extensibility and built in helpThe communityConfigurability and capabilityExtensibility and customisationStructural navigation (in lisps)Lisp, community, introspection, there is lot of packages, power of extensibility, magit, dired and org-modeIntrospection, keyboard navigationlisp interpreter + editorextensibility, customization & adaptability to the given terminal environmentrecording and replaying keyboard macrosExtensibility and versitility.Extensibility and good packages.org-mode and the extensibility emacs provides as a framework.Extensibility and packages created by the comminityMore options to configure it as wish, faster.Customization/Extensibilityless heavy than othersOrg-mode and numerous other packagesEverything is customizableI like org-mode especially! Emacs' universal environment for editing and coding.Lisp Machineelisp 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 powerLeveraging (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 communityText manipulation, minimal interface, portability, terminal interface, syntax highlightingpowerful, 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, lispI 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, etcLisp. 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 everythinglisp and lisp machine like designExtensibility, freedom, community.all these apps that live together and boost productivityorgmode multiple copy / paste undo redo commands working on 'selected region'It's extensibility, to turn it into an IDE for building your systems and applications.Opennessextensibility, elisp, packages,keybindings, extensibilityThe 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 itno mouseFree software, community project, customizable, extensible, keyboard driven.Discoverability, consistency in ui and concepts, very customisable, fairly easy to understandExtensionsEliso extensibilityOrg-mode, extensibility, customisation and availabilityExtensibility of course, but also the introspectability and self-documenting nature. The package ecosystem these days is amazing.ExtensiCommitment to free software, ExtendabilityExtensibility through programmabilityIt's a lisp interpretor with a giant suite of lisp programs.Extensibility as a TUI.elisp, package infrastructure, good documentation and help-functions1. 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 lispPowerful extensibility. Openness. Community resources. GUIThe editor is a text frontend to an interpreter. Everything good follows from that.customizability, broad range of pluginsPlain text front end which does not scare people starting.Extensibility and text manipulationpreservese rights of users, extensibleExtensibility with a lispflexibleFlexibiltyGreat packages, communityHighly configurable; portable "operating system" with a flexible GUI frameworkAbility 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 textExtensibility and lispSelf-documentation and extensibilityLarge amount of plugins, extensibility, text editing features, familiar environment on any platformLarge 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 functionCommunity and extensibility for sureExtensibility, multiple utilities are available in one interface (mail, news, calc).Clarity, simplicity and a rich ecosystem of packagesEmacs 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, extensibilitywealth of packages and configurabilityIt 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.malleabilityExtensible, all in one, lightweightElisp 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 experienceIt'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, packagesExtensibility org-mode magitConsistent extensibility. dwim, dired, xref, eldoc, icompleteExtensibility, live introspection/modification, rich but text-centric UI, support for functional programming languages, comment filling.The ability to easily explore the functions it providesCustomizability and creativity.productivity, easy consistent keyboard macrosExtensibility. More subjectively, I find the ergonomics to be quite comfortable (although I type Dvorak)Extensibility, cross platformExtensibility and the huge amount of packages to customize it.Its extensibility, which is greatly leveraging by an awesome and active community.It’s ecosystemI 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 packagesExtensibility and programmability via a lisp flavor. Great packages provided by the community.Maturity, community, freedom, lisp, packages, consistencypackages like magit and org-modeExtensibility & configurabilityThe packages people writeThe ability to debug things inside of the editor is frankly amazing. Being able to modify code on-the-fly.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 extensionsAmazing discoverability Amazing packagesFocus on text editing. IDEs use so much screen real estate for things I might use at the expense of the primary taskElisp programmabilityExtensibility, lots of non-programming packages, org-modeBeing able to make small changes where ever they are required.Full screen real estateextensibility via elisp, communityExtensibility 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, OrgmodePackages, customisable, keyboard drivenShortcuts 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 inThat is basically an extensible Swiss pocket knifeExtensibility, unique approach on different operating systems and possibility to use it in terminal and through SSH.* Everything is a buffer * Using ELispCommunity and FOSSIts foundation seems very well designed for extending, and it's got a lively community even now.Can be tuned and reprogrammedThe extensions, and good VIM/Modal keybinding support. :wIts extensibility and packages. Having everything (notes, code, email) in the same tool, using plane text as its go-to interop formatElisp, 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 terminalsProbably 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 featuresThe navigation keybindings are really comfortablehackability, extensibility, freedomIt has been here for a long time, and won't go away.Extensibility, discoverablility, ageExtensibility and consistencyLong term existenceEvil mode, elisp, long history of stable elisp for packages to keep working on, ability to be tweaked to interface with almost anything, TRAMP modeBeing 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-managementVersatility, 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, packagesLong history; extensibilitythe extensibilityThe richness of its introspective capabilities combined with a Lisp programming environmentModularity, extensibilityCustomisable, trustable, powerfulInteractivity, extensibilityCore is extremely solidCustomisability. 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 extensabilityText editing features, org, and huge package libraryGUI, built-in features/packagesTotal integrationExtensibility and ElegantPackages 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 thingsThe ability to do nearly all my tasks in a single applicationDocumentation - 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, elpaExtensibility 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 partsFree software, org-modeExtensibility and packageseLisp, runtime.programmable, keyboard drivenelisp, packages, communityCustomization and great packages (Org, Gnus, Magit, etc.)Extensibility, Org-modeextensibility, packages, like org-mode and lsp-supportSpeed and extensibilityThe packages that extend Emacs. The extent of customization.it is programmable editorIt'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 anythingmodularity, freedom, longevityComprehensive 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.Configextensibility and packagesCustomization, 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, ExtensibilityLong time stability and extensibilityProgrammable, extensible, evil-modeconfiguring, being lisp-basedEditingExtentablityextensibility, community that builds itBeing 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 emulationExtensibility, programmability, Lisp, free softwareGeneral 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 platformsCustomizability, Extensibility, Developer Community attention to detail, OrgModeMix of build in and community packages that make it complete computing environment. Dired, Erc, Gnus, org-mode, magit to name a few.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, extensibilityit's infinitely configurable and customisableits 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 fileProgrammatically ingesting / interacting with displayed text and other systemsThe 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 workextensibility, magitExtensibility and common platform to interact with many different tools.extensibility / programmability / one tool to do it allExtensibility, 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 systemUnparalleled 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 featuresExtensibility & 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 programsHackability, community.Based on Lisp, and self-documented feature, and the REPLMagit. Unlimited extensibility, easy to modify any key binding, persp-mode workspaces are in one window which is useful.(E)lisp as the substrate and the long-grown set of features.Consistency across the ages and incredible capabilityThe 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 customizationOrg-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 modeit is extensible, it has many packages, it is FLOSSExtensibility. It's theory of operation. Internal documentation.It's a kit to make your own editorI think the keybindings are really great as well as the new lsp featureExtensibility 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 sourceCustomizability, ecosystem & communityorg-mode, extensibilityLongevity, Packages and CustomizationSelfdocumented, extensible, configurability, programmability, multiplatformFreedom. A great community. It is continually being extended.None- many packages - extensibilityMouse independentIt has incredible versatility.Org-mode and extensibilityAbility to use proportional fonts. erc, magit, notmuch.Customization, lots of packages, stability, resource consumptionIt's as fast as vim, but it has better packages/add-ons and better features, like the calc or diredreal keyboard only editorFirst class user extensibility, fully introspectable workingsSelf documenting is fantastic and being configured with a fully fledged programming language.It's funDocumentation, sheer number of packages, long-lasting communityAs 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 packagesComing 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/osBuilt-in discovery and documentation and extensibilityComputers 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 sourceExtensible, integrated environment regardless of featureThe 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 HackersExtensivilityExtensibility and uniformity of interfaceStability.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 mainstreamBattle 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 runningExtensibility and productive features and available packages.customizability and extensibilityThe 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 textI 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, magitIt 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, communityExtensibility, org-mode, keyboard-drivenFramesEverything works together, eg spellcheck in git commit message buffersextensible, customizable, versatileExtensibility 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 textEnormous feature set - 10K commands! Excellent documentation. Org Mode.Mouse free operation. Everything is a function. Orgmodeits full adaptability to the hand of the workerThe 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”.Extendability. Customizability. The ability to debug it.Programmability.The "live" extensibility. Evaluate some elisp and run in right then and there.EVERYTHING could be tweakedScalabilityIts 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 yearsExtensibility, Keyboard-focusedmodularityExtreme customizability, large community, discoverability (through c-h v|f|c)Extensibility Live envitonmentExtensibility, the package ecosystem, default editing commands, builtin packages and featuresBoundless extensibility, debugging, introspection. All the power and flexibility of a lisp system.Extensibility, discoverability, packages, community, Emacs Lisp, org-mode.potential for usabilityIntrospection. Extensibility. 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 communityProgrammability, packagesCommunity, editing, orgmode, essProgrammableExtensibility, introspection, self-documentation.Extensibility, support for new languages, cross-platformEverything. Org mode, org roam.Editing speed, packages- doesn't get in my way, lets me focus on the text - there's a package for everythingAuto-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 - CommunityIt'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/extensionsSupport of the FSFAll 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 environmentsa long living software project that is not beholden to the interests of a companySpeed, flexibility, default GNU keyboard shortcutsExtensibility, integrations with OSExtensibility and being pliable towards the user's needs.Customizability, breadth of supported platformsI 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.Highly customizableCustomizability, Control over everything, Integration of features to form a smooth workflowBeing 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 timeCustomizability. Free software. Community. Future-proof.Long term stability. Doom really did bring me back to the platform.Extensibility, community, packages, freedomPhenomenal vhdl-mode package. General tweakability.Extensibility and keyboard driven workflow.Great joy in forging your own tools. Extensibility, freedom, productivity.the packagesCustomizability, great editing capabilities, org modeUnified interface to anything that can be represented as text. Can be made to do anything. Keyboard macros work everywhere. Programmable.Longevity, customizabilityThe 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, programmabilityIt'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 ofThe Community that keeps it alive. LISP!Org Mode, extensibility, Elisp, adaptability and configurabilityOrg mode, and LSP compatibilityIt'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 programmabilityFree and hackableBeautiful, clean user interface, extensibility, magit and other awesome packages, GPLThe 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 needsExtensibility, documentation, communityIt’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, extensibilityExtensibility macros/elisp shortcutsCustomization 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 possibleVirtually unlimited adaptation possibilities.Org mode with Babel. I spend 90% of my time in emacs in org mode writing and testning ideasKeyboard macros, elisp customizability org-modeExtensive key bindingacommunity, introspection, debuggingExtensibility, customizability, cross-platform, GUI and Terminal modes of operation.text editingExtensibility, implementation on multiple platformsAmazing 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, Magitintergration 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 vscodeextensible, functionallarge and easy-to-extend feature set which is very well documentedCommunity and LispExtensibility, 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.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 Stabilityhistory, community, extensibility, elisp, keybinding systemExtensibility and customization.Task automation and the ease with which anything can be automated. Magit/Projectile/org-modeThe flexibilityClojure support and very light editorkeybindings, and usefull extensionsMy 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, communityelisp, customizations.Extensibility. Multiple modes. Orgmode. Magit.extensibility, flexibilityExtensibility, timelessnessEmacs 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 greatEmacs as a lisp machine, introspectable, and tangible.Extensibility giving you total control over everything. Especially with exwm.Community, packages, malleabilityExtensibility, especially the ability to extend in an ad hoc way by live evaluation. Providing common facilities on different OSes.-flexibility -adaptibility - packagesThe packages and its extensibility. And org-modeCan configure as you likeEditing 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-systemYou can make it do whatever you want, besides coffee.It’s available everywhereOpen source, highly customizable, versatileThe clear extensibility, the ability to create programs that operate with the editor interface and componentsExtreme extensibility with a large library of well-maintained/well-documented community packagesThere 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.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-drivenlisp. in my editor.Still improving after so many years. Active community. Feels like $HOMEIntrospection 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 efficiencykeyboard-oriented workflowExtensibility. Amount of functionality.Programmability; generalized user-interfaceSelf-documentation Extensibility CommunityI 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 - elisp - 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 everywherecomparatively 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 coolHaving tasks, agenda, mail, notes and IDE in one place, all linked to eachother.PowerExtensibiiityorgmode, magitExtensibility. That it is a lisp machine.Customizability and its community1. 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 softwarecustomization, consistent key bindings among many packages/modes, open source, elisp, elisp sourceEmacs combined with i3wm allow me to create a very efficient workflow where my hands hardly leave the keyboard.Ability to fully customize programming workflowFOSS and extensibilityHacking every functionsconfiguration as codeExtensibility, configurability, complete freedomThe 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 needHackability, longevity, allround support for programming/prose/misc stuffUniversally 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 evolveHaving a familiar computing environment on whatever system I'm using.You can use it for almost anything, and tweak it to do what you wantRemote editing, eshell, workflow automationThe community that develops packages like magit, lsp-mode, ivy, projectile etcThat you can mold it to become anything you wantsimpleFlexibility/CustomizationHomogeneity (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.Lisp, extensibility, self-documentation and discoverability.Extensibility. Emacs can be the glue between a lot of different activities.Extensibility. Keyboard based usageit is the complete package. all you could want. all configured in the same language.keyboard shortcuts, support for many languages, speedWorks in a terminal Interactive code evaluationAll 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 functionalityOpenness, universality, no nonsenseExtensibility: the fact that many parts of my workflow can be done within the same tool, i.e. with the same keyboard shortcuts, etc.LibrariesDiscoverability by introspection, self-documenting, opennesExtensibility, documentation, and how easy to see and apply your changesPackage quality, Same keybinding for every apps.CIDER rectangles1. How every aspect of the editor is hackable and customizable. 2. Amazing packages (e.g. org-mode, magit, ...) 3. DocumentationEssentially being a Lisp VM with text editor utilities, and all the introspectability and flexibility that flows on from that.integrated with elisp so be extensiblePhilosophy, extensibility, community.It's longevity. I feel like I won't have to "learn" another text editor ever again.Customization and key commandsExtensibility, 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 licenseFreedom, flexibility, amazing packages, having a GUIAbility to extensively tweak your emacs configuration for your specific workflow and preferencesRich 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 knowBeing a Lisp machine which is fully programmable, software freedom (GNU/FSF)Not having all the features turned on by defaultI 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 languagePortabilityExtensibility, 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/flexibilityExtensibility, self-documenting, open-sourceExtensibility and customizability. Also, text being the first class citizen.The ability to bring everything into a single workflow under common keybindingsIntrospection, help system and communityIt's easy to setup and use a system for working on larger more complex projectsIntrospection, extensibility, community, org, magitextensible via elisppackage ecosystem, moderate use of resourcesExtensability and customability.Its modularity and extensibility.Magit, org-mode (babel, org-roam, agenda), built in GPG supportExtensibility 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 technologiesThe extensibility, the ecosystem, the communityVibrant 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 textextensible, open-sourced, Lispflexibility 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.Extensibility, customizability, and the wealth of packages people have shared over time.Ability to customize the platform. Ability to interact with code.extensibility, keyboard drivenits large community and its extensibilityFlexibility and extensibility Interaction between many packages Runtime inspection and debuggingVery big user base, and a solid foundation, allow for very good quality extensions.It's plasticityExtensibility 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, configurabilityVery powerful.Extensibility, elisp, org mode, plugin ecosystemIt has Coq supportIt is so versatile, always works, extensible and Lisp!opens anything, programmabilityIt'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 CommunityExtensibility, free as in freedom, community, org modeextensible, there is a mode for everything, not resource hungry, integrated shellExtensibilty. Ability to override any behaviour (I.e. with advice, literally *anything* can he altered) Comprehensive documentation. 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 sourceextensibility at will with lispEvery keystrokes are just invocation of elisp functions.It runs everywhere, is easily extensible, and has a large ecosystem.Flexibility. Tools.Runtime introspectionextensibility and readability of the language you use to customize it.Extensibility, history, self-sufficiencyAny aspect can be inspected and its behaviour modifiedelisp, core primitives for building applications with Emacs UI elements, such as texttl;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 endlessCustomisability and ExtensibilityTimeless. Will always be there.Many of the packages provide first-class solutions.Lisp is very powerful and allowsLongevity, extensibility, consistency on different OSes.More stable than Vim, great packages very well maintained. Light, extensible.extensionalityYou can handle everything if you want.REPL and interactivityextensions, great support for programming languages, org-mode, magitLisp osextensibility, longevityCommunity and packagesElisp, Keyboard based UI, Open Source CodeRange of packages, flexibility. Ability to do basically everythingelisp, 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 easyEverything is configurableEndless customization and entirely keyboard oriented.EcosystemExtensibility. It's so nice to override/configure any functionality you don't like/that you wantOne editor for all programming languages, no IDE requiredOrg 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 - Packagesextensibility, interoperability between packages / major modes / minor modesI can make it as simple or complex as I want -- a simple writing prompt or a full fledged IDE.Extensibility and org-modeExtensibility through packages and elispIts versatility in customizing various display features and its integration with other utilities, such as shells and debuggers.being a platform for editing applicationsAllowing me to create my custom workflow fairly easilyProviding a complete programmable system that works nicely for prose and code without being too modal.Free Software, no telemetry, lightweight, EWW, Gnus.Introspection, elisp, orgmodeThe fact that the GUI isn't just a terminal, it has styling, varying font-sizes, and SVG support.Freedom to do whatever you wantAbility to change anything to my preferenceextensibility. runs on most anything. I run it on everything from linux on my pinephone to my macExtensibility! (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 emacsOpen Source, useful features, endless flexibilityPackages 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 ethosopen, extensible, great communityExtensibility, self-documenting, moldableStructural editing via paredit, and composable extensions, when they do compose that is.Being extensible, self-documenting, interactiveNative 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 hassleDiscoverability, DaemonThe 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 ecosystemExtensibility, 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 freedomThoroughly complete, powerful, extensibility, huge number of packagescustomizabilittSimple, 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, CommunityOrg Mode - especially for writing (academic) text, mixing code, citations. Packages - having (M)ELPA got me back into Emacs.flexabilityfree, lots of other people use it so they've written many tips/tutorialsExtensibility via elisp UI stability Minimal initial setup No forced notifications and auto updatesExtensibility, huge number of packages for all conceivable purposes, org-mode, magit.Internal symmetryOrg mode; longevity; extensibleExtensibilty, Introspectability.architecture, despite its shortcomingsemacs is a platform that allows you to run full applications inside it org-mode is a huge strength that brought me to emacsSome packages (magit) Same keybindings, text nav in all languages Integration with some languages (Clojure)Extensibility and self documentingThat everything is subject to modification and extension.Extensibility, great self-documenting environmentExtensibility, customizability of every aspect of the editing behaviorUsers 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 possibilitiesGreat 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 vimextensibility and flexibilityExtensibility, self reflectionworks across platforms, powerful text editingElisp + communityCommunity, Extensibility and matured packages for almost everythingthe 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,Integration between different tasks, common interface for different tasksYou 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 bookEasy to install and configure plugins. Extensibility through elisp. Decent keyboard based workflowThe 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-modeExtensibility Eco-System Community Not being spyware also helpsExtensibility and exposure of everything over a singular interface (currently elisp)Extensibility, on-the-fly modifications, customizable.Its extensibility and its communityKeybinds and not using a mouseFast, extensible, good REPL workflowPowerful built-in features. A real built-in programming language that can be used too easily and quickly extend or customize emacs.Org Mode, extensibilityCompletely programmabileextreme customizabilityCulture, 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, extensionsThe enjoyment of building your own configuration. Flexibility and power when you start to wrap your head around elisp and the package ecosystem.variable-pitch-modepackages and org modeLongevity (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 applicationsExtensibility, introspectionGNU licence, everything is text, keyboard driven, elisp, shell-mode.It's fun to extend it with elisp. org-mode.Extensibility and REPLIts communityExtensibility 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 interpreterExtensibility Introspectibility Changing behavior at runtimekeep hands on keyboard. Mouse is not necessary.org-mode and org-roamextensibility & stabilityOrg 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 meExtensive package set. Great IDE once modified to my liking. Great customizability. Comprehensive Emacs WikiExtensibility. Self-documentation. Stability.Extensibility, lots of built in packages, community.Open source, extensible, incredibly passionate & helpful communityLimitless customisationMalleability and a great community of package authors pushing it forwardExtensibility and FOSSIt'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 packagesCustomisability/Extensibility, packages, the fact that it's not exactly a text editorEasy 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 togetherIntrospection, extensibility and ability to integrate with external toolsProgrammability / extensibilitynoneExtensibility, power functionsmagit, org-mode, good haskell supportImplementation consistency, extensibility, ease of inspecting the implementation, decades of useful packages.Elisp, gnu, the fsfExtensibility and magit org mode.Lisp because I can change how things work and debug on the flyThe great extensibilityNot 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 technologiesExtensibility and good support for many different programming languagesCustomisability, 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 supportFlexibility 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 ) ModesCustomizationsFully customizable, and I can fix most problems on my own.The package library, org mode is really usefulConfigurability, good support for multiple languages, the ability to do everything from a single program. TRAMP is very very important to me.History and Developer Communityuniform gui model and extensibilityExtensibility and can be run in TUI modeStaying power, customizability, availabilityextensibility TUI packages the way it has been developed for such a long time cross platformFlexibility and extensibility.Extensibility, efficiency, keyboard-drivenness (is that a word?)self-documentedKeyboard macros; built-in "packages store"; self documentation; GDB interface; awesome packages like lsp-mode, multiple-cursors, yasnippet.Extensibilty, org mode, notmuch mail, Just Worksextensibility, documentation, how configurable it isorg-mode and trampOpenness, extensibility, community.Elisp, extensibility above and beyond what is reasonable for most other editors.The way it rewards sustained investment.Extensibility, and some great packages by emacs communityCustomisability, extensively, integration with other systems (compile, grep, language server)Long-running free software project. Discoverability. Fine-grained customizability. Documentation. Exposes its Lisp interpreter for scripts.Extensibility, speedWide range of packages availableExtensibility, one-stop shop for many different needs, integration with external tools, discoverability, integrated help/documentationThe fact that it's a full-blown dynamic Lisp environmentAbility to modify things at basically every level. Self documenting.Extensibility, solid package ecosystemI 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 interfaceExtendability 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, extensebilityAny 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 anythingExtensibility, using a powerful and fun language.Extending functionality takes just a few lines of code, customization is a breeze.ExtendableextensionCustomizability, Extensibility, large package ecosystemCustomization and extensibility.Configurability/extensibility.Discoverability, inspectability, flexibility, ability to be modified at runtimeExtensibility, many ready packages, GNU-compatibility by default (GDB, mit scheme, and such), debuggability, excellent documentation, helpful community.It's the last lisp machine in useCapability to export text into any format. Can use every programminglanguage I want. Adapts quickly. Make notes and programm in the same tool.orgmode, extensibilityUnified Workflow that can be extended to all usecases.Extensibility, open customizationIntegration 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 practicesFree sprit and strong communityIt'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 Lisp Built-in helpDaemon/client model - being able to access the daemon from desktop or terminal (e.g. via SSH)Versatility, can do practically everythingEmacs 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.AllgoodExtensibility, Flexibility, and breadth of featuresThere's a core set of packages that are just stunningly powerful. Magit alone is worthy of an award.Dooms keybondingsorg 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 deftCustomizability, no coorporate ownerQWANPortability and customizability.TEXT EDITING CAPABILITIES AND ORG-MODE AND DIRED-MODECustomization. Text based. Community. Documentation. Solid bet (free software, won't disappear)One editor for all purposesIt 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 CodeWhere 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 skilladaptability to many tasks, ability to automate repetitive edits, integration with command line tools.infinite possibilitiesSmall gap between being a user and being a developer: Emacs is introspective and modifiable at runtime.coding efficiencyMacro 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 lifeIt is super extensible and can be programmed to fit each person's needsPackages, 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, communityFlexibility, consistencyFree, 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 Open source CommunityExtensibility 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. CommunityLisp and ageStability and flexibilitySpeed of producing text, speed of the program itself, hotkeysFlexibility and configurabilityConfigurability. Package library.Everything is a text buffer ExtensibilityI 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-infully customizableIts 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 packagesIts extensibility and wide array of built-in features.Extensibility, configurationNot doing things that i don't want it to doLisp OSEternal naturepretty powerful customizability / extensibility capabilities; efficent ergonomic primarily keyboard focused human interface; fairly performant, versatile and stable (lately); addictive keybindings (pro and/or con?)keymapHooksIt's extensibility. Elisp! The great community! Cross platform!Tool integration, for software development, but also general knowledge work, etc.doesn't get in the wayI can take the tools I learned to a new languageAbility to be highly configurable, and also one environment for many, many programming languages.Package ecosystem, open sourceWith other editors, I have to learn them. With Emacs, I shape it to be the editor that I want.Free Software, Extensive Community, multiplatformlongevity, extensibilityEndless flexibility.You can do a loro of things in it.Documentation, stability, versatilityFast ExtensibleIt's lightweight and reasonably fast.The tight integration of the Elisp runtime within the editor.Extensability/Hackability, easy insight into the state of the editorBuilt-in function such as org-mode, the vast ammounts of custom pagages and the ability to create my own funcitons and kbd-macros.ArchitectureMany 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, customizationExtensibility 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)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 GNULisp 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 everywhereKeeping the dream of the lisp machine alive.Org mode, packages, flexibility/programmabilityActive community of users and developersFree, extendable, dedicated community.I can tweak it for my needsmagit, eshellThe programmability of the editor.Extensible (elisp), packagesIDE in the true sense of the wordintrospection self documentation, discoverability, customization and especially org modeKeybind extensibility as compared to VSCode. More interesting packages from the community(things like hydra, which-key) as opposed to VSCode.interactive customizationExtensibility, customizability, huge collection of packagesExtensibility and customisabilityLight, open source, community-builtExtensible 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, packagesIntrospectiveness, the fact that it is designed as a lisp machine with an attached editor makes for a very great customization experienceEmacs Lisp, philosophyExtensibility in emacs lispWithout 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 magitExtensibility; and documentation such that extension is not a mysteryExtensibility 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-modeI 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 - Buffers - Bookmarks - Org modeExtensibility, 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, freedomFree Software, can be tuned extremely precisely, some packages (magit, org-mode).Flexibility, fired,. ..eloquent setup and configCoherent 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 elispOrg-mode Magit Lsp Evil Community Doom emacs Inspecting and debugging the code directlyPure 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 noneThe plugins have plugins! Info mode/docs. Debuggability. The vast array of packagesThe single unified environment for keyboard oriented computer use.Extensibility and many mighty packagesText editingExtensibility, Interactivity, self documented, discoverabilityextensibility, the fact it’s a gui app (can mix fonts, show images etc), org-modeExtensibility, magit, distraction freeLisp ecosystemExtensibility, makes it stay usable over decadesThe 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, configurabilityExtensibility & opennessself-documented, customize by elisp, keybindingsExtensibility, community.Elisp, keybindings, packages, communityExtensibility 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 platformExtensibility, 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 togetherExtensibility you're the extremeExtensibility & s-expressionsExtensibility. 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 systemThe 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 platformsbuffers connected to processesprogrammability, extensibility, easy connection between packagesExtensibility, 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 extendedHigh potential for inter-package synergyCustomisability, extensibility, and the rich package ecosystemAbility 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 customizationIt changes your mindset opening to many more opportunities.Complete extensibility, ecosystem of packages, capable community willing to help, configured with Emacs Lispextensibility, portabilityThe packages and introspecability.org mode, extensibilityPackages like auctex, or-mode, magit and suchExtensibility, small footprintBeing able to work with little to no distraction in a powerful environment.extensibility and large library of major packagesExtensibility, Free SoftwareExtensibility, Lisp, Org ModeEdit and eval any elisp at runtime1. It is literally a Lisp virtual machine, which makes the environment unique and irreplaceable 2. The ecology of the software packages accumulated over the yearsFree software, in both cost and freedom, maintained by a community.special modes, elisp interpreter, ability to be used as an interfaceStability, compatibility, extensibleELisp! 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 itextensibility, ubiquitous natureMalleability, keyboard-centered editingCan 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,Extentability, packages, communityExtensibility, building ones own environment tailored to their needs/desiresExtending 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 workIt can do absolutely anything, including posting time cards to jiraEmacs 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 abilityExtreme extensibility, lightweight application, simplicityTramp (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. Multiplatform, Lite (specially on terminal) CustomisableproductivityOrg-mode, extensibility, interoperability of componentsmagit, daemon modeOS-like in the sense that you can do a lot without switching to a different app.Its community which writes clean and modular packages, extensibilityExtensibility 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 principlesextensibility, possibility to do everything from within Emacs.Extensibility via Emacs Lisp.Extensibility architecture, Common Lisp integration and debugging toolsExtensibility Universality (one editor for everything: text, programming, e-mail, calendar, to do)History/license/stance, buffer/text/input paradigmSource code is available, self-documenting and modifiable at runtime. Emacs includes amazing packages: Org, Magit, Mu4e... that can be combinedIntrospection, extension, elisp, “os”y architectureelisp extensibilityYou can change almost everything to your likingworks in GUI mode as well as terminal mode built-in programming language ORG modeLisp, community, flexibility, portability, mobile-orgExtensibility, 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 configurationContinued development and improvement. Performance. Flexibility.its works and its fast(only when using vanilla)org-mode (with clock table), pdf-tools, org-roam1. 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 configurationGood conventions, community and freedom from limiting coding principlesExtensibility, still relevant after 50 years, plugins (magit, lsp), org-modeSeamlessly 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-modeIt is very comfortable, with great bindings.Robust, open, not tied to whims of companyBeing built on top of lisp, feature rich packagesEmacs 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, extensibilityCommunity, Extensibility, PackagesThe 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 ExtensibilityI 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, extensiveEvil modeFree/LibreIts extensibility and great packages.Standard interface across languages.Support for programmingIt'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 editororg-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, helmKeyboard everywhere.- 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 spiritExtensibility 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.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 bindingsDocumentation + community and extensibility. The first two make the third that much easier to get into.Community and packages for extending without big limitationsI use vimThat its free software Elisp melpaDoomIts extensibility and universality (“it’s an OS, not an editor”)integration of functions related to my entire development workflowextra packages like magit, notmuch, eglotIt's easy to configure and build your own "personal operating system".editing features/packages like magit etcthe package infrastructure, confidence in long term survivalStability. Community.Simplicity and extensibilityEasy 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 laterYou can tweak or extend almost anything, so that Emacs seemlessly fits into your workflow. Also: org-mode!Moldability Lisp Free Software Keyboard-drivenLegacy, 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 playgroundI 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 packagesBeing 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 itselfOrgmode and its extensibility.The extensibility and package diversity.Institutional knowledge of editing, stability, packagesI can use it for whatever desktop digital task I could be involved in.The extensibility and ecosystemExtensibility and speedone editor to rule them allI 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 ttyIts 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: registers dired trampExtensibility and solidness, has been there for a long timeLots 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 documentationThe 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* loads of keybindings also valid in terminal (bash), which makes it easier than vim * programming language specific pluginsA 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 wholeextensibility; packages like magit, orgFreedom 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 documentationMagnificent 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-modeText navigation key-bindings; [package] extensibility; integration with the OS.Extensibilty Being nonchalant about fitting in to the mainstreamExtensibility, org-mode, open sourcemouseless 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 machinesIntrospectiveness, 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 seamlesslyEmacs 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, customizableExtensible with rich packages.1. Extensibility 2. Community which provides documentation, packages, and innovation 3. Org-modeI 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 extendedFlexibility, 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 timeDocumentation, commitment to stability and backwards compatibility, configured through a "real" programming language.Extensibility and programmabilityExtensibility and vast number of packagesExtensibility and having a native gui lets eMacs unlocks a lot of functionality that felt hacky in Vim. Packages like magit and orgI can fully customize itExtensibility 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 packagesfree software, time-proof extensibility, macro recordingPackage manager, free-libre, infinitely customizable, available almost everywhereI 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, customisabilityExtensibility and well written documentationExtensibility and programmability. It can be configured to the very last detailExtensibility , 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 softwareEmacs 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 reliableIt 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!) - customizabilityKeyboard-centric UI, customizability, and extensibilitySelf 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 personalConfigurability using elispIt does everything I need and probably everything I might need in the future. It's fun to modify and extend things via elisp.Freedom Extensibility Lisp DesignExtensibility, "C-h f" "C-h v" are simple things that changes everything ^^The extensive collection of packagesYou make it your ownExtensibility and configurability using code rather than jsonLightweight, takes less processing power than VS code.being free software, not being a web browserA unified computing experience thanks to an extensible 2-D text metaphor and cohesive programming languageivy ,vertico, helm search engine, elisp, extensibleFlexbility, portability.compatibility, community, programmability (not just extensible, modifiable)Having a consistent UI for a wide range of text-based activities. Programmability 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 editorIts ability to evolve and transform over timeExtensibility, Lispbuilt in lisp environment, org-mode, magitEmacs makes it learning and working fun while using.Packages, the ability to run on pretty much any machine, remote editing that just worksEvery prebuild action is already also a function that can be used programatically. And then bound to a key.elisp and extensibilityMature project. Fast enough but full equippedThe ability to tailor it for your workflowFlexibility, customization, integration with other tools.Everything is immediately available.jack of all trades all-rounder, extensibilityEase of customization and extensibilityExtensibility, customizability and vast number of packages available from elpa.Flexibility and freedomextensibility, free license, customizability, learning curve isn't actually that badThe 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 freedomA lot of packages with great commuityIt’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 extensibilityIt 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 & ButterfliesHistory, package ecosystem, extensibility, freedom.org-mode evil-mode Other packages that are good, too.Configurability, supporting anything, huge number of packagesby far its extensibility -- being able to rewrite core parts of it as it runs is extremely powerfulExtensibility, flexibility, longevity, availability on wide variety of modern platforms, open sourceCustomizability, 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, extensibilityExtensibility, programming language supportElisp, extensibility, customization, org-modeExtensibilty, 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/ElispElisp extensibilityExtensibility, image renderingLisp programmingcustomiztionIt'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 imaginedExtensibility. 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 - extensibilityThe 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 UXMicro-communities around it, like doom-emacs communityFull control via lispFull featured and customizable for my WorkflowIts 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, packagesExtensibility, availability, versatilityExtreme extensibility and customisationOne editor for everything; customization and extensibilityKiller maintained packages (e.g. org-mode); extensibility; dedicated communityIt'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 yearsExtensibility: 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 - gplIt 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 MacOSOpen 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 ownOpen source, hackableKind of standard, lots of functionality, extensibilityConfigurability, Being able customize both the packages and the editortext editing, great packagesIts 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 experienceExtreme extensibilityExtensibility and community orientationthe community, elpa/melpa, It just works! I've had hundreds of buffers open for weeks on end, no crashes.org-mode, viper-modeUse Lisp to configure everything of the editorThe super low barrier to entry to start extending it with the user's desired behavior + the homoiconicity of lispIt 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 itthe fact that Emacs is not a text editor, but a lisp interpreter that works beautifully as an editorIt’s design: Modes, map, hooksExtensibility: ability to easily customize almost any aspect of the editor and try out customisations immediately using the elisp REPL; Org modeIt automatically closes paranthesis and can display them in multiple colors And it has a cool git integrationExtendability + 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 inKeybindings & 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/melpaOrg-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 packagesEditing, 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-modeIt is free software with great customization capabilities.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 levelRelatively easy extensibilityEverything is customizable on-the-fly via elisp without mucking with plugins written against some stupid APIs.magit and evil mode. introspectionExtensibility and wide range of packages available. Plus org-mode.Customisability.Buffer model.Modularity and the global surrounding environmentDiscoverablity + tons of packages + customizabilityextensibility through lispThe conservativism towards superficialities and dedication to free software.Its programmability, complete customizability, and TRAMPCider, magit, and trampExtensibility and Keyboard MacrosKeyboard focus, org mode, magitI 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 editorOrg-mode, great built-in documentation, high discoverability of functionality, and a decent package ecosystem. It's really org and babel that keep me around.TweekabilityPlatform 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, customizableMalleability. 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 situationIt's one tool for many things.unified interface to everything, mail, writing, versioningPlainText and flexibilityfun to use, extremely customisableWide availability of packages and stock completness.- customizability - flexibilityExtensibility & customizationExtensibility, packages, batteries includedLow on resources, and keyboard driven, and the extensibilityThat it's fully introspectable and hackable.Its extreme flexibility, and exposing the complete internals of the editor to scriptingEmacs Lisp and its extensibility.The customizability.Extensibility, power, intuitive keybindings, enormous ecosystemIts 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-modeExtensibility, 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) 2. extensibility 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.MallableConsistency 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, magitExtensibility, better vim than vimEcosystem of users and packages.Customizablilityextensibility, ease of writing little interactive functionsCan be run in GUI. Elisp > Lua > Vimscript. Has useful help commands.Customisable, packagesOrg Mode, large "marketplace" of extensionsintegrated text-based environment, extensible, opinionated also support for lsp is very importantruns on many systems, and has superior code/text editing capabilities vs other options (excluding vim)customilzied, lisp-liked langaugeThe 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 extensionsModifiableConfigurability: the potential to change everything through packages and variables; Flexibilty: everything can be changed at runtime, at will;Lisp machineOpen source, extensible, fun to programExtensible in lisp, open source, healthy package repos with good variety/coverage.extensibility, and lots of ready to use community packagesEasy 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 ElectronBeing 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 emacsExtensibility at-the-coalface text manipulation and navigation freedomDefinitely 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 inReach 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 extensibilityextensive amount of addonsDocumentation is Emacs greatest strength beyond extensibility.Extensibility, good workflows (and related snippets) available online; It's a Good Text EditorExtensibility, flexibility, packages. You can turn it into whtever you want. It's a framework for text editing applications.Free software, extensible, great packagesProgrammability; 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! Programmabilityextensibility & communityExtensibility, opensourcekeybindings, unified UI for different languagesBeing able to do everythingNOT 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 amazingI 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, communityThe 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 pluginsIts extensibility and rich ecosystem of packages.It's packages for all-purposeConfigurability, 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 stabilityFree software principles, extensibility/adaptabilityIts maturity and the maturity of its packagesdabbrev-expand, dired-mode, LSP supportThe extreme amount of "customization" one can do via lisp.extensibility, rich packages, org mode, community, it just worksunlimited 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 featuresExtensiblityAbility to change the behavior and customizeElisp. 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 commandselisp for better and worse, package repositoriesNo telemetry.Extremely configurable. All includedSoo many featuresYou 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 flowextensibility through elispExtensibility, text formattingEmacs' 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 elispExtensibility, Elisp, and the fact that it appears to be EternalConfigurability, extensibility.More than just an editorCustomizability, wide community support, terminal interface with daemon/client which is not available in many other GUI IDEsprogrammability, long history of useful packages- Extensibility / customizability - Org mode - Ability to run in terminal modeKey bindingsExtensibility, great community, independently open source, battle testedmagit/orgConfigurability/extensibilityEverything works well together. Easy to integrate the features of two completely unrelated packages.Keyboard navigation and controlIts 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 openExtensibility, ability to configure to your needs.extensibility and the documentationFree 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, communityIt 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 communityI 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 soonHuge 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.SimplicityExtensibility. 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 communityNon 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 introspectionExtensibility and hackabilityOne 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 - community - orgmodeIt'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 LispPackages for every language.uniform text ui self documentingAbility to write settings in lisp* the simple navigation with keybindings * Extensible * Best Clojure Repl (Cider)The elisp, many extensions and the keybinding.org-mode and how damn hackable it isExtensibility, 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 itorg-mode, customizable, elispThat 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 EmacsEmacs' 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.BasicExtensibility; 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? StringBachelorsMastersSchoolPhDAssociates
When you discover a new package that looks interesting, what do you do next? Vector{String}Install and try it immediatelyResearch alternativeswait for communitywait for maturity
Which version(s) of Emacs do you use? Vector{String} special fork18.249.028.69I don't use Emacs25.0162.019.320.1whatever comes with the distrojust my bf's22.3I don't know, whatever is on my repos19.0?23.0Whatever is installed21.1223.14159218.5919.34
Do you use any selection packages? Vector{String}VerticoIvyConsultHelmNoMarginaliaframework defaultIdoSelectrumIcompleteFidofidoOrderlesscompanyfido-verticalfido-modefido-vertical-modeEmbarkmctother packages require way too much cpuI think Ivy, I am not sure.anythingxxxxxxxxxxxxxxxxxxxxI don't knowMostly the built-in completion UISpacemacstrying out, but undecidedMct??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)xselcounselemacs 28+ improvementsi can never rememberI use vimI've looked into them, but not used one.fzfdabbrevwhich-keyfartsauto-completemcEmbark, Orderlessicicles, if that countsWoah what, since when were there this many options. I just remember the first couple of those.CorfuVcompleteDoes "companion" count?smexUsed Ido, then Ivy, now my own thing, breed between ivy and verticodefault minibuffer completionI don't remember whichSwiperfido-vertical-mode from IcompleteYesIcomplete-vertical (built-in)my own cursor position undolusty-exploreruseelm, and IVy, currently on Ivy. love itfussy, corfuWhat's a selection package?I don't understand the question.avyselectrum-prescientConsidering switching to Vertico+ConsultIdo was good till the vertico comes, vertico-marginalia-embark rocksraven
How do you learn about new packages? Vector{String}RedditBlogsWeb search enginesGitHubM-x list-packagesGNU ELPA/MELPA online package listsMailing listsDiscordIRC serversMatrix serversDiscourseHacker NewsTwitterYouTubeYoutubeI don'tyoutubefriendsSacha ChuatwitterColleaguesFriendsHackerNewslobste.rshacker newssacha chuaemacs-chinaHNEmacs Chinaplanet.emacslife.comTelegramnews.ycombinator.comFediverseepkgMastodongooglehackernewstelegramsachachua.comEmacs wikiHacker newsemacs chinaTelegram chatI don’tdoomSacha Chua's Emacs newsLobste.rsfediverseEmacs Wikiemacswiki.orgDebianGoogleemacs wiki4chanHacker News (HN)Planet EmacslifeSacha Chua's blogyoutube videosMeetupsDoomI don't use packagesmastodonemgSasha ChuaGoogle searchemacswikiemacs-china.orgsachanoneAdoption into Emacs coreYoutubersi don'tEmacs NewsImageboardsnot at allSacha Chua's Emacs NewsWorkYouTube videosSacha Chua!I don't.lobstersSacha Chua’s Emacs NewsStackExchangePlanet EmacsI dontN/ASlackcoworkersEmacs-Chinai dontEmacs-chinacolleaguesYoutube videos/g/Sacha Chua's weekly emacs newsCompany slackRSSemacs.stackexchange.comYouTube tutorials/channelsColleagues; Hacker News commentsI dont, reallyn/anullHacker News commentsI 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 ChuaI basically don't; haven't added anything new in yearshackernews, lobste.rsProt YouTubeStill learning about old packages.... HN mentions them sometimes, as does emacs-wikiXMPP discussions4chan /emg/Sacha Chua's excellent Emacs news postingsContent CreatorsSasha chua newsletterOf course Sacha Schua, she deserved an entry hereemacslifeChecking other people's init.el filepacmanI usually stuck with defaults :(Sascha!youtube emacs videosOnlyfansemacsconf, Xah Lee tutorials, Sacha Chua emacs newsEmacs-JP community (Slack)emacs-jp SlackinternetSystem Crafters YouTubeDebian apt list elpa-*Doom Emacs ModulesWhen I need a featureEpkgsI use vimSlack, Twitterspacemacs codebaseSacha Chua's "Emacs News"Twitter, YouTubeM-x straight-use-packageSacha Chua blogVideosVarious SlacksSacha Chua's newsletterSacha chua's blogSacha Chua newsletterSacha Chua BlogSacha Chua's weeklySacha Chua's Weekly Emacs NewshnHackernewssocial media, fediverseSascha Chua's newsletter almost exclusivelyThe emacs rocks seriessacha's Emacs newsEmacsWikiSacha Chua's weekly Emacs NewsHaphazard.twitter, news.ycombinator.comSacha's newsletterirreal.org, Sachua ChuaQiitaguix packageshttps://www.youtube.com/user/mzamanskyEmacslife RSS feedSystem Crafters Youtube channelgoogle, stackoverflowlobste.rs, hackernewsStackoverflowtwitter, emacs-newshttps://emacs-china.org/Sacha Chua's Emacs News (as linked from LWN.net)I don't - not keeping trackStack Overflowlobste.rs news.ycombinator.comfreebsd forum, arch linux forum, hackernewsSasha Chua mailing listTwitter, colleaguesupgrade doom-emacsYoutube, word of mouthEmacs news - Sacha ChuaLooking at the code of distributions like Doom EmacsYotube channelsTelegram Emacs CommunitySacha Chua's weekly summaryTwitter (and recently Mastodon)Sacha's emacs-newstwitter, telegramI don't!AccidentDebian package manager, sometimes the webYouTube, including Prot and David WilsonYouTube channels like System CraftersColleagues, Hackernewssacha's emacs weekly postwork SlackMastodon; by chancei 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 melobsters, fediversegoogle searchsSacha!https://sachachua.com/blog/ and Telegram channelsEmacs Wiki, and on FediRecommendations from colleaguesdescribe-package with vertico completionsword of mouthUnsureemacsconfDo not really learn about themplanet.emacslife.com, Sacha Chua Emacs Newsemacswiki (why is this not an option?)Looking at the emacs config of other users in Githubi dont use emacsPlanet.emacslife.comI usually don't learn about new packagesycombinator newsFriends on mvp slackhttps://news.ycombinator.comI search my OS's binary package repo for packages to support new languages I'm picking upsystem crafter, Sascha Chua newsI don't, maybe emacs news mentions somethinghttps://sachachua.com/blog/category/emacs-news/I don’t really find out about new things. Would love to thoughI'm unaware about Emacs packages and therefore don't learn about new (or old) ones.sacha chua's weeklyGenerally only bother checking when a need arisesarchlinux.org/packagesTalking to other usersPlanet Emacs feedtelegram existis fsfSacha Chuas awesome weekly Emacs NewsborgSeeing other configs that do cool things!Emacs News!Jabber roomsGoogle itSacha Chan's weekly Emacs newd/g/ and HNSacha Chua's Twitter updatesVideo sharing platformsxmpp emacs roomwhen I have a need for a feature I search the list of packages, or google the needword of mouth / friendsMy own MELPA Atom feedsTelegram groupsHN, talking to colleagues, built into doom, occasionally Twitter. I used to list-packagesWeb browsingProps to Sasha Chua and Planet EmacslifeM-x straight-use-package recipe completionDon'tMy frameworkHacker news (rarely)notSacha Chau's weekly e-mail and Emacs MeetupsEmacs-related mailing lists: "Emacs Devel" and "Emacs Humanities"I do nottg and emacs chinaHacker News (Y Combinator)YouTube. Systemcrafters and Prot’s YT channelsEmacs News (by Sacha Chua)rarely use new packageshttps://planet.emacslife.com/Mastodon, other people's configsrandomlyyoutube channelsI don't reallyfrom people I follow on Twitter and MastodonDon't use packages that don't come with emacsFollowing the Emacs # on Mastodon!I don't really try out new packages, but occasionally find some on githubSacha's weekly Emacs news ❤️Emacs wiki; GuixDoom emacs curationI 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 internetTelegram chatsDon’tBy accidentYoutube content creatorsmostly youtubeHackerNews, YoutubeNone, I don't pay attention to new packagesplanet emacslifeSacha Chua blog; Debian packageSacha Chua's blog in particularPeoplediscussions in emacs-china.orgSpacemacs LayersSlack workspace: emacs-jpTalking to friendsEmacs wiki too. I seldom look for new packagesI do a web search when I have a requirement.Social mediaI don't care about or use new packagesYouTube(SystemCrafters), https://sachachua.com/blog/emacs/4chan has a dedicated thread on /g/In-house discussionscolleagues, also Hacker NewsEmacsmirrorYoutube videos and presentationsNone reallyfriends and coworkerssocial medialwn.net's weekly links to the emacs updatesRandom Internet searches when I want a new featureI don't! I don't know where to get information about new packages!Doom EmacsI don't. This focus on packages surprises me a bit. I didn't know they were such a thing.Books4chan /g/AccidentallySystem CrafterRecommendationSacha Chua's Mailing List (thanks Sacha!)Japanese community in slackSearching source and emacs git logsAptitude new packages listYoutube, Mastodon (social media)sachachua.com/blogssachachuah4chan's /g/ emacs threadEmacs-China forumI always use list-packages firstnot actively monitoringHacker NEwsa 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 keyworddebian repoGuixSacha Chua, planet.emacslife.com (and previously planet.emacsen.org)YouTube: System CraftersActivityPub/MastodonNot sureMOOCsI don't learn about new packageseMastering emacs bookSpacemacs Gitter channelI dont really go looking for new packagesright now I am intentionally not seeking packagesgooglingEpkghacker news discussionsothers .emacs.dEmacs news from Sacha ChuaYoutube, like "system crafters" for exampleY Combinator Hacker Newsemacs-newstelegram groupsHnsasha chua's weekly emacs newsletterword to mouthnoDachau’s Chia’s eMacs news; searching for packageshuh?elfeedCourse guides when providedslack channelGoogle + I don't need new packages"Emacs China" forumsearching for themPlanet EMACSSacha shua linkstips from colleaguesYoutube (system crafters mainly)People talking on twitterYoutube (system crafters is probably the biggest such channel)Distro Tube, System CraftersSystemCrafter's Youtube streamsdoom emacsemacs news by Sacha ChuaCompany chat roomI check for relevant packages if I have a specific neednews.ycombinatorDoom Emacs DiscordGoogling when I need to solve a solutionguix searchnot actively looking for thatSystem Crafters youtube channelOften via EmacsWiki or general web search.Videos on LBRY and YoutubeNews.ycombinator.comI don't keep up with itM-x paradox-list-packagesYoutube. Especially Systemcraftersi don't?The list in Doom's config filesOperating-system distribution package listsSlack channels at workdependsSacha Emacs Newspairing with coworkersMentioning in podcasts.Sacha Chua's Emacs in a week.Don't know what a package isNEWS-file with New emacs versionEmacs mailing listHackernews, youtube emacs channels, twitter, spacemacs configsGNU Guix package listSacha Chua's weekly newsSacha Chua’s emacs newsGoogling for themVarious4chan /g/ Lisp & Emacs Generallobster.rswatching YouTube videos on emacsstackoverflowEmacswikiEmacs Weekly NewsEmacs News (Sasha Chua)emacs newsplanet.emacslifesystem crafters and as neededYoutube channelsGoogle, let's be honest most people are searching "how to fix/do X in Emacs"GNU Guix package searchArtix repositorySacha Chua Emacs newshttps://www.emacswiki.org/Sacha Chua - Emacs WeeklySystemCraftersRSS feeds that list new packagesNew packages in the Debian archiveRSS feedsSacha's Weekly NewsMy framework/starter kit's updateMelpa RSS feedarticles on ycombinatorthe emacs wikiSachaChuaplanetemacsenI do not use packages anymorehttps://sachachua.com/blogSacha Chua's awesome blog!based on need and Googleemacs-chain.org telegramemacs feeds4chan's /g/ boardtelegram group https://t.me/emacs_ruguix package list, sachachua newsUsing web searchdoom emacs I have stopped learning about new packagesemacs-china telegram groupDocumentationOrange siteTwitter, especially Sacha Chua's weekly emacs news postsTelegram groupSacha's feedemacs-tw/awesome-emacssachacSacha Chua's weekly listlobste.rs, hn, corporate slack channelother people's public configsemacswiki, ergoemacs, etc.no, must not be answeredI don't. I simply look for appropriate packages when I need one. If it ain't broke, don't try to fix it!maybe youtubedescribe-packagesearch engineYouTube videos (Distrotube and System Crafters)Very rarelyYT System CraftersSystem Crafters, Distrotube etc youtubeI hardly look out for new packagesstraight-use-package (keyword)Search engine when i find a deficient in emacsRSS feeds with elfeedusenetSacha Chua! Thank you! Hugs!Sacha chuaI am not interested in new packagesPlanetEmacsLifePlanet emacsSasha Chua’s Emacs NewsEventsemacs news by sachachuaSascha Chua’s Emacs newsHardly, randomly, google a functionalityS. Chua's blogemacs-cnFriends/colleaguesSacha Chua Emacs NewsColleguestelegram chatnot reallynixpkgsi don't use third-party packagesI don't learn about new packages.Colleagues and friendsSacha-Chua Emacs Weekly News
How often do you contribute to packages? StringNeverRarelySometimesOftenFrequently
Where do you ask for help using packages? Vector{String}GitHubRedditEmacs StackExchangeIRCMailing listsFrameworkDiscordEmailMatrixDiscourseI don'tTelegramgoogleGooglen/aN/AI don’tnoneNonei don'tSlackI don't ask for helptelegramEmacs ChinaI don't.TwitterFediverseI dontweb searchColleaguesi dontfriendssearch engineFriendsWeb searchMastodonI do notEmacs-ChinaGoogle searchemacs-china.orgnowheredon'tmastodonDon'tNever haveWeb searchesi haven't-notMy friendsslackSearch EngineSearch engine/g/searchI never haveDuckDuckGoNever didInternetSearch the webemacs-chinaread the sourceI don't askfediverseemacs chinaNever had toWebTelegram groupslinux.org.ruclojurians slackI haven'thave not done soGitterSearch enginesI figure it out myselfinternethaven't yetFriendDuckduckgo4chan /g/I usually don'tnever haveFigure it out myselfI've never needed toco-workersdontI don’t ask for helpI don't knownever asked for helpHaven't done itNowhereNever needed tonevercolleaguesSearchGitLab4chanClojurians SlackTelegram chatStackOverflowduckduckgoWorkdocumentationnonaemacswiki.orgSearch EnginesJabberCompany slacktwitterGooglingi just read the documentationGoogle (search for help)nullI have never done soDon't ask anyone. Searching information on internet and reading the sourcesI have never had toHackerNewsI have never raised a questionWeb Search (Blogs, StackExchange etc.)slack (work)just search onlineNever doneI 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.EmacsWikiEmacs local communityAsk a friendsearch the web, don't askgoogle until I find an answer.Look up the internet and solve for myselfNever asked for help.I just don't. I probably should...Google or read sourceRead the documentation + sourceLocal emacs communityI have not had to ask for helpIt hasn't occurred in a very long time.RTFM and/or look at source codeI don't, reallyemacs-chain.org emacs-telegram grouptelegram existis fsfUsually, I don'tC-h fi often just do a google searchdedicated emacs thread on 4chan /g/ boardGoogling aroundLocal Emacs community at SlackI've never triedblogs, web pagesUsually don't ask questionsI read the package's source codeFriends & ColleaguesGeneral internet searchhacker newsgoogle, stackoverflow, I read source code of packagesImageboardsWherever help isthe source / package documentationI don't ask, I work it out/research myself.I don't ask any help, just give upCoworkersJapanese Emacs community in SlackI don't. I read up on already available info if problems arise.Maintainer's choice of forge (e.g. sourcehut)Telegram chatsReadme, CodeInformation Super-collider (WWW)duckduckgo and source codeif I can't figure it out myself, then the package is too confusing to bother usingnever did itsocial mediai never asked for help before. i just read manuals and search for answers in the internetI don't really askI don't ask and try to figure it out myself.Don’t askinternet searchemacschina4chan's /g/ emacs threadWeb SearchI check the docs and source codeNever did thatDuckduckgo search. I figure it out or I move on.Never asked, only researchedYouTube tutorialsGenerally, I don't.ActivityPub/MastodonI have never felt the need to do soIRL FriendsTelegram emacs communityHowever it applies to package, but I mainly search available contentRead the sourceUsually search for others having the same issueI usually use a search enginedon't knowGitlabdont ever ask, will usually give up on a package if its not workingHave not done thisI don't ask for help.never ask for helpI read the sourceGoogle which often æeads to StackoverflowGoogle it myselfNever have done so.usuakky google => emacs.SOgoogle/duckduckgo searchGoogle and/or manual debuggingEmacs channel on work slackuse search engines more intentlyI don't ask for help but I have found answers on Xah Lee's wiki and Stack Overflownever had toI've not needed toHave not asked for help yet.I do not use packages anymoreweb search engineRead the manual, search the webFriendly Lisp and Emacs Thread on 4chan.org/g/search on the internetI don't, I can usually solve my issues through research, such as source code and other internet posts.company slackI haven't asked for help.I did not yet askHacker Newsgoogle.comI've never askedI'm shy, i debug it myselftelegram chatI never asked, if I can’t solve it reading the docs I remove itI don’t; I fix them if I care enough to do so.see aboveread the codeNever asked for help with a package …haven't needed to yetNowhere, generally try to figure it out by myselfSource codeForumI don't use packagesGoogle-itJapanese community on SlackI haven't needed to askI din'tI never doemgMainly no issues so far. I'm used to finding issues on github first. Usually helps.i simply cryStack OverflowI don't ask for help, I search the web for solutionsI choose another packageemacs user group at workemacswikiHaven't needed to yet.own tinkeringI 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 similarread docs and search webGoogle and built in emacs helpN/A, haven't had to ask thus farJust read the docs or GoogleI don't; I read what others have asked./g/flet/I don’t. I fiddle with it until it works, or abandon itSee above. I don't. The community sucks and is notoriously hostile and most people _sprint_ awaynever done soI research and figure it out on my own. If I think there is an issue, I report that on the repo or mailing listHave never asked for helptg and emacs chinaclojure slackYouTubeAny 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 generalDon'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 googlingSearch first, have never ask right now.don't ask for helpI don't, too shy :)Social mediaA frientOther Emacs users I know in real lifeI mostly don’t ask for helpI just read the docs and the source, I never ask, only lurk.Coworkersearch for help on internetsearch enginesI can't remember ever asking for help using packagesI look at the sourceI read the source codeHuh?Not needed toDo not use packagesUsually find the answer with a simple google searchI haven't askedNever done soehaven't done itHave never done soI don't know how to use mailing listsMastodon, various tech groupsThe web.web search enginesI don't do it generally, but when I do, I just use the channel that's most supported by that package's communitynever asked for help (yet)Google & readhaven't seen the need toI 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 frameworkI don't usually I fight my way through it or someone has already had the question answered on the webWeb search enginesI never didNo help required. Usually the packages are rock solid and have great docs or code.webjust internet searchWork Slackread the docs? Google?never ask helplook at source codeAsk friends. I haven't had great experiences from traditional emacs support channels.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 alternativeEmacs-chinaI have yet to do so.IDKGoogle to find out moreI don't think I ever haveGoogle, then give up.Web search (passive)FacebookI don't ask.Emacs-JP (Slack)Twitter, Slacktelegram group https://t.me/emacs_ruAsk my friend who got me into EmacsFriends & coworkersI almost never doprivate work slack emacs channelI just search for information on the webI don't generally need or ask for help.I figure it out myself.I'm a lonerI never ask for help. This question should not be required.I read the code and fix itI don't ask for help, but I search stackexchange, reddit, and blog postsnever seems to occur to me to ask for helpEventsIRC was a shitholeemacs-cnWherever the package documentation directs me togoogle for it or give upweb searches? I don't really ask for help for some reasonI don't ask for help, I can mostly find the answers in documentationfriend, try and errorSearch for help, rarely ask.I don't tend to ask for helpWhatever google turns upHave not done so4chan /emg/Read the source codeYoutubenowhere; SE or emacs-wiki generally has the answeri don't, i just search the web and the docsGoogleingThe source code of the packageNever had to do this. Usual web search pointed me to the relevant places.wechatI use vimwork teamsDepends on package. Avoid rfeddit, stack overflow and other forums. Might use github issues if package github based.I switch editorshtmlGoogle :'()People in my office buildingUsually 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 yetBrowsing existing answersuninstall packageprimarilly reading documentationsuffer in silenceemacs community inside my companyask friendsNevermatrixwork SlackI never ask for helpnever, so farusenet, bitdreading docs and source codeI 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 BBOARDI mostly don't, I don't know of a good real-time and active Emacs chatReading documentsemacs-china.comGoogle web searchI haven't needed to ask for help in a long timeI usually just search for helpwhere recommended in their readmeI've never botheredgoogle searchIt's own documentation and/or codei usually don'tnever didsearch the internet or talk to a friend; documentation is really great, just add some additional elisp and you get it doneGitHub (unfortunately, because most of the repos are hosted there)Read the src / google / sourcegraph search for uses of itRead the sourcesNaNdig the internet and docsCodebergI 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, documentationWork slackI don’t askBoyfriendhaven'tfriends and coworkersno timeThe FSMI haven't needed to do so yetdocumentation, emacs wiki, source codeJapanese community in slackInternet search, and the manual (if present)searching on the webemacs-china tg groupI didn't ask so far, figuring everything on my own, I am shyjust googleI don't?Twitter or MastodonI tend to research and experiment on my own as I don't want to bother peoplenever really botheredI 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.FatherI usually struggle aloneI look it upreading the documentation, other users experience writedownsIf I need help I drop itjust searchI limit myself to the internetFediverse, Twitteri don't askI have not done so yetEmacsRead documentation, watch Youtube demonstrationsFriends and colleaguesBlogHardly askseach on the netemacs meetups, otherwise I just lurk the weblearn by selfright now I am intentionally not using packagesI don't rememberI haven’tGoogle, I don't want to bother the authors too muchgoogle?I haven't had to ask for helpEmacs-jp4chan's /g/ boardSearching the internet for hoursOn the Fediverse, usually.Telegram groupNAforumsearch on the webMy brainPackage mantainer choiceSlack, etc.work slackvarious how-to websites/articlesFriends/colleaguesusually find an answer through web searchNever done itTyping questions and complaints into Google SearchI don't ask for help unless I find a bug, there I ask the maintainersi have a codementor.ioAsk to coworkers on SlackNever been necessaryI never have asked directlyAsk a friend who knows how to read elispI just google itColleagues, Clojurians SlackI never ask helpTelegram channelemacs-jp SlackF2F with coworkers - or I figure it out on my ownI search for the answerI 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 workEdebugnever happenedHaven't yetNever happened so farDon't really ask, either it works or I need to read moreXMPPusually I search and find an answerI just hack around it until it worksDocumentation or web search orNo idea where to askWhatever is availableRead the manualStackoverflowHaven't asked for help beforehttps://emacs-china.org/I read the documentation and/or codeNot asking for helpNowhere, I read the source codeFirst place I canI tend to work it out for myself. Documentation in emacs is fabDuckDuckGo / give up and try something elseRTFM, source.don't ask, only searchNaNone of the abovenever done thatI don't and use any info available and the source code more often than notSearching in a search enginei dont remember doing thatDiscardColleagues/friendsemacs help and devel newsgroupsDoom Emacs Discord and the channels #emacs and #doom-emacs on the Clojurians SlaclNot at allI never had tocolleagues on slackGoogle search.The internet...I don't, generally.Friends IRLnowhere so far i thinkHaven't asked for helpxmpp emacs roomInternet searchI don't. Source code is out there.Recurse Center Zulipnever askedDon’tHaven't needed tonever needed yetJust search the internet.duck-duck-go searchLast resort is to read the code.i hack until my emacs system fulfills my needI 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 onI 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 helpBrowse the sourcegenerally I don'tDon't bothergoogle + pounding head on wallI don't really feel comfortable asking for helpEmacs wiki, search enginesSolve my problems on my ownamazingly, I had no need to ask for helpgenerally, i don't--if there's insufficient info already available, I pass on the package or dig into the code myselfusually, I don'tduckduckgo :)web search which leads me to any of the aboveGitHub, but would prefer free alternativesnot requiredIf I cannot find it with an internet search I will use the included docs and figure it out.Company chat roomman and targitlab, source-hutGoogle search usually gives me what I wantnever had a needI usually find what I'm looking for onlineDon't know what a package isI read the source code and try to figure it out first.Hasn’t come upgoogle onlysearch on Google for answerpublic Jabber/XMPP roomstackoverflowNotboards.4chan.org/g/Company chatfigure it out myself or abandon itstack overflowread source codeI generally don’t and just search the internet instead of askingi just read the docDocumentationGive upHaven't neededI usually use only the features that I can access with the help of Internet searchesDuckduckgo:)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 doOnline searchThe package sourceI don't, I just figure it out or stop using the packagei don't ask for helpusenetI don't, either I can get it working with the docs and Google or I don't use it.Other source forgesHave not askedI read the doc, then package elisp
How do you manage third-party packages? Vector{String}use-packagepackage.elframework defaultstraightmanualnot sureelpacaNixguixnixleafGuixquelpasetup.elel-getleaf.elGNU GuixborgCaskDebiannixpkgsBorgapt-getGuix package managern/aDoomaptSpacemacs layersDebian packagesdoomDoom EmacsSetup.elNixOSdebian packagesnixosNixosNix package managerparadoxQuelpapurcell's require-package (based on package.el)trySimple custom use-package alternativepacmanleaf and Easkgit submoduleshome-managerStuff packaged by my Linux distro. And a big custom .emacsI use vimdoom version of straightnix module (rycees emacs-init.nix)don't usedistro package managerrarely use third-party packagesleaf (alt use-package)Paradoxdebian packagingqelpaguix packagesDIY to learn really how autoloading worksportageI copy the *.el files to site-lispPortage (Gentoo package manager)el-get.eldoom-emacsUsing nix in practice, specifically https://github.com/nix-community/emacs-overlayguix package manager, or elpaGUIX package managervia Doom's facilitiesstraight with leaf.elI don'tpackages downloaded and added in my "init.el"use package in the few minimalist configs i haveLeafNix (emacsWithPackages)modify examples provided by doomMix of git submodules and custom discovery code for optional stuffparadoxäleaf.el (and Guix and a fallback on straight)Debian packagenix/guixleaf, guixdistro provided packagesapt where possibleguix, setup.elI do not use them. My use-cases are very simple.Guix, Nixi dont use emacspackage.el hacked by meNixpkgs + use-packageEl-getUbuntu’s elpa-* packagesi don't use git, i stick with one version foreverI use a git-sumodule in my dotfiles repo to manage use-package itselfnix package managerMy distribution's package managertrack installed packages in a separate git repositoryidkwhatever ships with emacsUsing vanilla Emacsparadox.elMostly manuallywhat ever doom uses (straight?)Nix overlayI plan to use guixinstall via nixI check my elpa/ dir into version control and use a tool I forked to commit each package update separately, to enable bisecting in event of issuesWhat Doom's doing :)system package manager (portage)null - everything is hand-carved into .emacsSome are installed through my distro (debian) package managerNever used oneI install packages using Guix's main channel, and the elpa/melpa Guix channel when they have not been packaged for the main one. Then I use use-package to configure them in my .emacs.nix emacs-overlayDistribution - DebianDebian packages + Git repo with my config and third-party code as Git submodulesDoom combines straight.el and use-package, with modifications.WinGIT in Visual StudioFedora rpmspackages.el via a custom unless/package-installed-predicate-dolist, also git clonehaphazardlyGNU Guix using an Emacs configuration service (I defined myself) which attaches to the home-profile.APTnix-community/home-managerdistro packages (debian, nixos, guix)ELPA, MELPADoom's package! command, sometimes with a recipe to get it from githubhave some functions I wrote myself to help out.A custom nix derivationGNU GUIXI still have some el-getA custom wrapper on top of use-packagenix/home-managerCustom solution to fix package.el and all of the half-baked solutions out therehome-manager on nixosI don't use any packages that do not come with the emacs installationnix's emacs-overlay for installing and rolling back packagesMy GNU/Linux distribution's package managernix-community/emacs-overlayUnreleased package configuration manager macrosno clue, I get confused a lotnixos home-managerdoomemacsSome from the Arch User RepositoryPortagequelpa :(Nix / home-managerdoom emacs literate configuration modeI use whatever the OS suppliesNixOS frameworkcustom setup from long ago, not used in a long timeSystem Crafters' emacs tutorialsmy own cursed thing i'm calling yokeI've heavily customized package initialization to minimize interaction with customize for multi platform / multi system differenceesdoom, straightWhatever Doom doesborg (git submodules)Do not use anygentoo portageSpacemacs (i.e. a combination of the above, including Quelpa and 'manual', but it is not 'yet' ideal)package.el + my own thingUsing Guix GNU/Linux package manager.NixpkgsDon't know what a package isWhat Doom Emacs providesNix emacs-overlayNixOS emacs-overlayhome-manager in nixosLooking forward to package.el getting vc installation features!nix + leaf.elI only use those that are included with my OS's binary package repositoryquelpa + quelpa-use-packagedoom does it for meemacs-overlaywhat third-party packages?asp (AUR)I do not use packages anymoreguix package managerSpacemacs configurationDebian packages manager (apt/dpkg)I generally only install 3rd party packages from debian repos. It's a pita to have a package-manager for every language.nix expressionshome-manager (nix)my own automatic configurator, upgrade and OS executable dependency management all user-defined functions out of both Emacs-Lisp and Bash modulesNix and Guixnix-community emacs-overlaymy new config avoids (nearly all) external packagesDoom emacsstraight.elspacemacsNix (with the "emacs-overlay" facility)will try straight when more comfortable with my setup.M-x package-list-packagespackage.el + Borggithub: xuchunyang/epmI use debian and I install some emacs packages via aptGNU Guixpreferably via debian packageInstalled from my GNU/Linux distribution's repositories (Debian)purcell/emacs.di don't use third-party packages
Which operating system to you use Emacs on? Vector{String}GNU/LinuxMacOSWindowsWSLBSDAndroidNixOSLinuxHaikuAndroid via TermuxOpenBSDGuixtermuxSolarisUbuntuCygwinandroid via termuxITSLinux via TermuxguixcygwinnixosAndroid via termuxtops-20n/ai dont use emacsSolaris, AIXI run my OS in Emacs.Haiku-OSaix, solarisandroid/termuxGNU/Linux VM running on Chrome OSNo OSI don't use EmacscrostiniI use vim on LinuxDOSNEXTSTEPChromeOSWindows via cygwinMultics and ITS (yes, still)bf'sOpenbsdFreeBSDmusl/Linuxmy own osAndroid TermuxOmniOSwindows+cygwin (very rarely)in windows - vmwareAndroid(termux)vimAlpine LinuxGuix SystemOrg ModeManjaroGNU EmacsHurdandroidAndroid mobileITS, Lisp MachinesArch linuxAndroid with termuxBusyBox/LinuxLinux via Crostini on ChromeOSGuix on top of GNU/Linuxmsdos0->1Windows with CygwinAndroid / TermuxCygwin, AIXprogramming, bash, gdb, filesystem browsingDebian LinuxHaikuOSGentooOpenVMSAndroid (Termux)Windows via Cygwinlinux via crouton on chromeosRaspberry Pi OSRaspbiantempleOSAixArch Linux
Which editor did you use before you started using Emacs? StringVimNoneVS CodeSublime TextNotepad++IntelliJEclipseAtomvinanoNanoVisual StudiogeditNeovimKateVipicoGeanyjoeGeditBBEditedNotepadPicoJoeKakounejedneditTECOTextMateNetbeansneovimnvimceditNeditMicroEmacsjEditTextmateRStudionotepadNetBeansMicroemacsvisual studioNeoVimbriefgeanyGEditDon't rememberUltraEditkakounePycharmBriefmicroemacsVisual studioVariousAcmeTPUJovejedit