Emacs User Survey — 2022

9871 results also available as Text, CSV, TSV, JSON, SQLite DB, JLD2
Do you use an Email client in Emacs? StringNoMu4enotmuchGnusWanderlustRmailmewMH-EVMMewvmmh-eI want toI 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 gainfirefox from within exwmHTML 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.that is on my TODO listTried 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 IMAPimapNo, but I want to eventuallyI 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 editorTried itNo but I'd like toNot yet but I plan tomuttI want to!
What do you think are Emacs' greatest strengths? StringExtensibilityextensibilityElisporg-modeelispOrg modeExtensibility.LispFlexibilityCommunityCustomizabilityCustomizationExtensibility, communityOrg-modeconfigurabilityProgrammabilityorg modePackagesflexibilityEmacs LispExtensibility and communitycustomizabilityIt's extensibilitylispIts extensibilityOrgmodeMagitOrg ModeExtensibility, packagesmagitCustomisationExtensibleCustomisabilityIts extensibility.orgmodepackagesAdaptabilityextensibleVersatilityLongevityextensibility, communityThe extensibility.The extensibilityElisp, communityExtensibility and customizationextensibility, elispcommunityprogrammabilityExtensibility, ElispDocumentationMalleabilityExtensibility and configurabilityCustomization.Extensibility and the communityextensibility, customizabilityExtensibility, CustomizationHackabilityExtensibility with ElispExtensibility and freedomextensibility and stabilityIt's extensibility.ConfigurabilityExtensibility, introspection, documentationlongevityfreeCustomizability and extensibility.Self-documentation and extensibility.Package ecosystemHow customizable it isIntrospection and extensibilityExtensibility and ecosystemversatilityall in oneConsistencyFlexibility/extensibilityextensibility, configurabilitypackages and extensibilityStabilityconfigurability, org-modeExtensibility, documentationStability and extensibility.Emacs lispExtensibility, elispExtensibility and discoverabilityExtensibility and maturity.MacrosORG modeProgramabilityExtensibility 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.extensionstabilityextensibility and communityConfigurationExtensibility and customizabilityCross platformExtensibility, customizabilityelisp,extensibilityExtensibility and documentationcustomizationExtensiblityextensibility through elispFreedomExtensibility, org-modeconfiguration/extension, packages, doesn't force me to work any particular way, runs everywhere I need it.Elisp. Elisp means Emacs development can move faster than any other editor, and the Emacs community can produce disproportionately good plugins for its size.Very easy to customize to fit my workflow.n/aFree 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-modeIts IDE capabilities.Extensibility 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.Someone else already thought of that. Configuration is code.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...libre software, text manipulation is possible everywhere, magit, org-modeconsult/embark is the only thing keeping me from using vscodeAge, malleability, adaptibilityelisp 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 Lisp and its extreme extensibilityEmacs is highly extensible, which helps it achieve a very high amount of packages which extend the core functionality of emacs.Complete extensability and flexability using a lisp.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 communityAll-in-one package. When something big is installed and works OOTB, then it works beautifully. I felt that Doom Emacs is cutting a lot of config time compared to vim/nvim. But: when any detail breaks in those big things it feels way more difficult to fix than nvim.Complementary 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.what are you twelve? noobExtensibility 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.I can program everything that I want and has org mode and magit.Doesn't need an internet connection; can chanfe the behaviour and appearance of (almost) everything; when input is requested it is not modal and I can change buffer even when the minibuffer is asking for something.Lisp for configuration is just the 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 incredibleautomation of the writing with enough experienceUI, 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 performanceThe extensibility. Always when I find something I don't like I know if I were more knowledgeable I would be able to tweak it.Extensibility 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.Extensibility, and Freedom.It’s a lisp machine with some great text editing built on top.I could tweak it to suit me perfectly. Also I am huge fan of defining everything in code, and emacs, especially doom let's me do just that perfectly.Wide ecosystem of packages; numerous use-cases for technical and non-technical purposes.Configurability and 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 discoveryuser friendliness, 'no surprises', extensibiity, dired, onboard help, packages like helm, ztree, magitFlexibility 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.Keybindings are separate from input the input method, i.e. I could be writing in Korean or English, the keybindings are the same (unlike some editor called Vim).Feels like I can edit any corner of any option and customize to my 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,EXWM is one of the main reasons I use emacs. The best window manager I've used so far, the greatest thing about emacs is emacs-lisp and org mode.extensibility, org-mode, magit, 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 modificationKeybindings and customizabilitykeybindingsCan 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 casesmodesThat is a living, breathing, fluid, programmable dynamic environment, that is interopable, discoverable, reactive, can be deeply at will introspected (as in its own state, self-documentation etc), easily hacked, modified, integrated (both, internally within and outside the environment), composed and limitlessly extended.dynamc, extensibile, self-describing, open-source 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 baseIt's configurabilityExtensibility, 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.Elisp and keybinding flexibilityHis extensibility and org-mode.Extensibility and observability and freedom - to make it mine.His extensibilityAlmost 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.Extensibility; shortcut consistency: rarely do I need to switch context in my mind to press correct shortcut and thus trigger a correct action, wherever I am (coding, writing, doing API requests, interfacing with OS)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)Inspect state, make changes as it runsThe 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 integrationsCustomization ability.Community, 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 performanceI can make it my ownVersatility.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, extensibilityReally open sourcekey 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 libraryEfficient editing. Programming language support (highlighting, inventing, etc.), tool integration (make, tags), extensibility.Extensibility, openness, maturity, standard and consistent way of dealing with everythingHighly extensible and powerful. Magit! Org mode!Extensibility, 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 textConfigurability and the ability to have every tool I need in one place.org-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 useCustomizatoinExtensibility, configurability, speed, Elisp being so elegant, massively ported, etc.Scriptable 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.Organazation of notesText 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 platformsPackages like org-mode, org-roam.Flexible 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.Ethics, 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 magitThe replThat 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.- programable - org-mode - packages in generalThat 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 documentation- Extensibility - An actual programming language for configuration, customizatiin and extensions - Comunity.The 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, configurabilityfamiliar environment for different tasksIt 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.Besides being the great editor, it can be used as the keyboard-driven UI for almost anything.It's a Lisp; it's Free Software; the community around it; some great packages such as Org.- Keyboard shortcuts. - Really open-source. - It works (very few bugs, not spending my time on a bug tracker is a good thing for an editor. I tried PyCharm and spent my time on their bug tracker).The architecture as a programming language with some built-in text editing functionalityextensibility and Lisp interactionThe whole concept of living runtime, and that a keystroke is an event than can be captured by any mode, to provide a graphical interface used with buttons.Extensibility and customizability as well as community culture that promotes writing packages that are oriented towards customizingarchitectureMultiple buffers. Never have to use a mouse. Speed of development.extensibility, configurability (due to breadth of packages available)extensibility, discoverability and lispExtensibility and absolute freedom and moddability.It 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 PackagesIts extensibility, community, and it libre-nesss.Speed 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 bindingsEasy 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)The extensibility and flexibility, Emacs is more of an operating system rather than a text editor, which no other editor can offer.All of the flexibility and functionality that is just there, esp. with text related modes. I used to write a lot in LaTeX and docbook. I could be productive just by scratching the surface of emacs and (for example) AUCTeX.- Built-in elisp, facilitating customization and package writing - Huge variety of excellent packages (both built-in and external)Extensibility and 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.org mode, ecosystemExtensibility, 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, extensibilityExtensibility, community and the free license.Modularity, 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 CustomizationExtensibility, paradigm consistency (it's just a bunch of buffers)Vim keybindings, great packages, customizationBetter customizability and org-mode + org-agendaLarge community and adaptabilityExtensibility, 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)I found it easier to configure than vim, with a better ecosystem of packages (that include evil mode),Adaptability, emacs outshines vim as the complexity of packages grows and the user’s desire for more diverse functionality increases. Also the help system is unrivaled.Free in all meanings; longevity and permanence; flexibility; 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).Extensibility, discoverability, millions of useful featuresYou 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-documentationUltra minimalistic UI capabilitiesits 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.You could pretty much replace your entire operating system with it. The keyboard driven workflow saves so much time and is tremendously efficient after the learning wheel is over (never is over).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 is a free software editor which is designed to be extensible by being written in lisp and having its functionality fully available to the user.Everything is text; everything is extensible; elisp is matureIt 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.Speed, extensibility, no need for a mouseThe 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.extensibility, decent language- 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 helptimelessThe 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.Free software, vibrant community, elisp interpreterI 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, Communitycustomizable, documentation, easy to grasp source code, 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 macrosExtensibility, Portability, Org mode, magit, dired.editing, magit, terminal mode, trampBuilt for keyboard shortcuts, fast, encourages 'finger memory'.Light weight compared to other editors.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.The extensibility and flexibility. Besides being fast and very complete in terms of features.It is a uniform interface to a large variety of applications.easy to extend.Extensibility, lightweightness, ELispExtensibility & customizability, great and active community projects/support.Note taking in org mode, magic, free software principles.Longevity and stability. Great packages like magit.Extensibility, being GPL licensed. It is miles ahead of any other program in these regards.Strength of the community and the wealth of 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 flexibilityMost of it is written in elisp, which allows it to be self-documenting and easy to extend. The possibility to communicate with external programs quite easily. Dired, org-mode.lisp interaction mode for easy 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.Everything is text, everything is auditable/modifiable easilyPackages 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 packagesIt has a lot of built-in commands which are very handy.Integration 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.Extensibility, unified experience, self-documentation, community, the best text-based work flowSelf documenting Elisp - extensibilityIt's fully customisableOrg-mode FlexibleThe extensibility is great. There are many features built in of course too but they are not intrusive. Personally I find the emacs key stroke philosophy preferable to all others and am frustrated when I have to work in software that doesn't support it.Documentation, 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.Can adapt it to do exactly what I want to do the way I want to do it.The ability to do multiple things with a unified keylayout and all programmed in elisp.Amazing set of packages. Vanilla emacs is 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 packagesIt's a wonderful program. Also, its customizability.The extensibility and the community, and it's open-source.terminal / daemon + low memory footprintIt's like vim++ with doomCommunity!org mode; it is a revelationEmacs can be configured to be almost everything to everone. I'm a DevOps engineer by trade and needed mostly an IDE-like experience for Ansible, Python and bash scripts. Doom helped me a great deal towards that and the Emacs community in general is pretty quick in picking up new things like LSP, tree-sitter etc. Having a Lisp as configuration language makes much more sense than VimScript.simplicity. 'all is there'.Extensibility. I like that it's a lightweight Lisp Machine.dired macros Extensibility rmailintrospectability 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.Keyboard driven workflows and extensibility.I see Emacs as a text-centric shell and like the "flatness" of its design and integration with packages: it allows for a multitude of connections of simple bricks which interact and reuse each other. Its other great strength is Elisp, and the fact that almost all code can be redefined while Emacs is running.Extensibility and the community of great 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.default key bindings, extensibilityProgrammed and configured in Emacs Lisp, active and enthusiastic user community, huge selection of extension packages.Relatively easy to change anything. Nothing can be pet peeve in Emacs except for lack of pet peeves.Common interface between platforms (Unix, Windows, everything else)Being so self a documenting and being less an editor as a complete hackable system is incredibly powerful concept. Its like seeing the future of computing but receiving it from the past.The potential for working at the speed of thought.Change what you 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, predictableI would be lost with out org-mode. Moving around buffers, having multiple buffers, split frames. Macros and scriptabilityMatching 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 + extensibilityFOSS, customization, extensibility, stability, long heritage (also a weakness)The C- and M- usage. There are no editing mode like in vim. Also it has many packages. Good integration with hunspell. Great for 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 extensibilityA framework I can hang anything into using specialized programs (perfect UNIX philosophy); limitless 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 onesEmacs really thrives on its customization and extensibility features. I mostly use it for programming math simulations or formatting latex documents.Org mode, Slime and evil. Its vim with a very good note system and 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 editing. And all amazing minor- and major modes.The customizability and great packages like Org, Magit, lsp-mode.extensibility and just general power, was vim user which I love but its too hard to really twaek. Emacs is just "more" very happy with the decision to 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.the adaptability for each user preferencesInspectability 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, diredIt's extensibility through Emacs Lisp, and the growing number of packages rewritten in more modern Emacs Lisp frameworks and whatnot. The community of users and developers is excellent as well! I love watching System Crafters, and the Discord server for that YouTuber is great, along with the Doom Emacs Discord server (even though I am a Spacemacs user).The customization and extensibility. I also appreciate the ideas of the FSF but I wouldn't say I am a die hard 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.Shaping it to fit the user's needs exactly, built-in tools (Magit, Org-mode), package variety, starter packs (Doom)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 extensibilityIt's free software. I ditched Atom when Microsoft bought GitHub.Extensibility 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 customizability of the editor are very important. Also the relative consistency of experience across development environments is a big plus to me.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 learnedI think the greatest strength of Emacs is its extensibility. The design of the application and its inherent "modularity" are what make the ecosystem flourish. That and being an entirely keyboard-driven editor which is ubiquitously available is fantastic.No nonsense by 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 editingextensive and reasonably good documentationRich text supportExtensibility, Free Software values, large and active communityextensibility 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 usabilityOrg mode, Org-roam, literate programming, Magit, great VIM keyboard supportBeing 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.clean code to customize + easy to inspectorg 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 / trampthe extendadility of its core, the plain text, its configurability. It's not opiniated about anythingI 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).The extensibility and the wealth of packages.Able to use vim keybinds lolThe greatest strength is how flexible and malleable it is to cater to all of my needs.configurableFree 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 hackabilityI can do what I wantWhat 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-editingextensible, 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.It's extensibility and the fact that it's been around for so long that it has a large number of high quality packages available.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.Elisp and the insane speed it enables, once muscle memories and workflows develop.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 open source. Everything can be tweaked with code.Extensibility 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.Community and Extensibilitykeeping 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 longevityStill learning, can't tell, but extensibility is surely great. Full leyboard navigation is also lovely. I don't like T-based editors like nvim/helix, while VS Code does some funny stuff to my laptop. We don't talk about JetBrains here* Efficient keyboard-based navigation * Efficient use of screen real estate * 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 everythingThe possibility of being as basic or as powerful as you need/want both at the same time.Extensibility, some amazing packages, and the fact that it's free software and not controlled by a corporate like Microsoft. I'm at the stage of wanting "forever software" and Emacs is one of those.It makes people excited about working on it. While it may not be the most efficient way to do things at the start, I believe that it is a positive on the long run.Terminal support and emacsclient.Elisp, packages, community, been there since 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, magitI love it's extensibility. It can be as simple or as complex as you like and there is robust community support.- 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.Batteries included language, bonus points for it being a lisp variantPackages, 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.Being a "real" free software. Having a philosophy behind which so far has outlasted any other.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, magitOrgMagit, a proper extension languagekeyboard shortcuts, elisp, GPLBeing 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 modeExtendability.Extension 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 MagitIt can be your OS if you want it to be.having 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, minimalist look and MagitExtensibility, 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 clientOrg mode and the fact that it is an elisp repl first and foremostEvil 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 timeEmacs Lisp Stabilityopen 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)Configurability, and the resulting community focus on work flow and efficiencyFreedom 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 offEmacs is free software at its best: I can understand and customize everything! And there is a great community around!Customization, open community, easy extensibility, and the plethora of historical packages.1. It works; 2. I have muscle memory; 3. While I rarely take advantage of it, the extensibility makes it incredibly versatile.adaptabilitytrusta lot of capabilitiesIts extensibility and built-in features. I can write, run, and compile C code and even read along with a book in doc-view-mode all without leaving emacs. Eww is an underrated browser and loads images very well in GUI emacs.Extensibility for me is Emacs' greatest strength, also the awesome community.Extensibility, Lisp, 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 modeThat it's an Elisp execution machine.Full lisp environmenteverything is a buffer. Very discoverable. Good documentation.Some 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, ecosystemIt was here 25 years ago, it will be here 25 years from nowUnified interface, easily extensible, excellent community.Simplicity and complexity at onceOpen, dynamic, historyCustomizability, extendabilityCustomization, shaping to my mindFreedom, 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, FOSSAnything can be done with the keyboard, and the various operations are very uniform.Its customizability/extensibilityExtensibility, 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, extensibleDiscoverabilityExtensibility 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.malleabilityprogrammable in a Lisp dialect; Great internal design choices (major/minor modes, keymaps, etc)Extensible, 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.I can always follow-functions of my editor and the code being edited to immediately have full transparency and troubleshoot outside of external language server issues.The flexibility that (almost) everything is written in, and can be customised with, elisp.Macros, rectangle replace, extensibility- Extensibility, built-in package manager. - Built-in documentation, great community and knowledge bases. - Possibility of doing almost anything with one software. - Strong connection with free software. - Not changing too much, too quickly. - Longevity.Extensibility of 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 consistencyIts built-in packages like Org Mode or Magit, its extensibility.Long 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.low latency typing experience, extensibilityExtensibility, 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, communityThe extreme customizability and extensibility are unmatched in any other editor. Writing in multiple programming languages working pretty much equally well as each other.Customization and great packages (Org, Gnus, Magit, etc.)Extensibility, Org-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.It is customizable beyond belief. There is a package available for virtually everything.Consistancy through the years, everything that worked when I started using it still works.Extreme familiarity; after perhaps 45 years, there's a lot of muscle memory built up.Switching buffers and moving the cursor position within a buffer. I used to use Ivy, now I use Consult and Vertico. Without these packages, I would have stopped using Emacs.Org, 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. The packaging system. Orgmode. Magit.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.package ecosystemBased 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.Elisp. By far, elisp. Vimscript and VSCode JSON/TS make me puke in comparison. Following that, simply how it integrates beautifully, and composes so well for tasks like managing emails. Message-mode is the best composer I've ever used. Not to mention that it's extensive, in a way I cannot name. The other day, I typed in C-h f treesit-query-compile RET and it took me to the source code. I've never seen that before. C source code, mind you! Not to forget that it's extremely powerful out of the box, and now, since it integrates tree-sitter, eglot, PGTK, and others, I can confidently say that it (has the potential to be) is above and beyond all other editors, uncompromisingly.(E)lisp as the substrate and the long-grown set of features.Consistency across the ages and incredible capabilityDeep customization. I am never in a situation where I have to remain unhappy with the default behavior of my text editor. TRAMP. Only this year has VSCode released a similar remote package functionality, and it is far weaker than Emacs'. Rich text WYSIWYG. Font faces allow for things like inline previewing of markdown.The extensive ecosystem and extreme configurability.Great packages: Magit, org, etc. Mostly unified way to do things.The Community. Specifically: The big focus on having incredibly powerful extensions that are entirely controlled by the keyboard.Easy 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 editorgod tier font rendering packages elispI 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.Extensibility and Community. There is a package for everything, and if not, I can write one easily.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).You can adapt most modes to a non-qwerty layout. Elisp documentation is very discoverable. It's very portable with pure elisp packages.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/os* Focus on the keyboard * Highly mature project * ExtendabilityBuilt-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.I'm using doom emacs and it just works and has everything I want out of the boxPackages. 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”.Extensibility, there is such a rich ecosystem of packages out there.Extendability. Customizability. The ability to debug it.Programmability.The "live" extensibility. Evaluate some elisp and run in right then and there.EVERYTHING could be 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, packagesLisp, and the hackability that comes with it.Community, editing, orgmode, esscan stay focused on the home row of the keyboardProgrammableExtensibility, 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 everythingMinimizing context switch by allowing me to do all my work in one tool, with a keyboard driven interface.Auto-documenting, dynamic (C-x C-e & friends), stateful. Powerful TUI framework without the limitations of the terminal (e.g., via 'make-frame-on-display'). Emacsclient.Extensibility & configurability. The fact that I can make it do exactly what I want via macros or writing my own functions makes me want to do everything in it.- Extensibility/ Power - 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.Its package ecosystem, and the community that continues to tirelessly maintain it. To be clear, I'm referring to the Emacs maintainers as well as the thousands of people on GitHub / the internet building packages and Emacs distributions that continue to care about giving us a mature and *modern* development experience.Highly 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.Extensibility that goes beyond any other text editor.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 packagesExtensibility, customisabilityCustomizability, 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.Extensible featureThe 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 flexibilityIt's applied metaphor and extensibilityClojure 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 likeMinimalismEditing 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 everywhereAbility to change almost everythingOpen 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.It's lightweight and has a good macro systemIts 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.it is malleable to your needs with lots of packages to choose fromPowerExtensibiiityorgmode, 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 evolveThe ability to do more useful and faster actions without the gosh-darn-awful mouse.Having a familiar computing environment on whatever system I'm using.You can use it for almost anything, and tweak it to do what you 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.Extensibility. Everything can be done from emacs.Lisp, extensibility, self-documentation and discoverability.Extensibility. Emacs can be the glue between a lot of different activities.Extensibility. Keyboard based 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 evaluationExtensibility, keyboard oriented with Bash like keybindings, searching interfaces (Ivy/Helm).All the packages and the "lispiness" of the software itself (i.e., being able to interact with everything).Support for huge range of programming languages; org mode; customization of appearance and 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.Community of smart people making convenient and well thought out toolsIt'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 communityLisp programming, keyboard shortcuts, low power usage on my laptop, very robust and stable packages. I haven't had to install anything third party yet because doom emacs has everything built in.It's easy to setup and use a system for working on larger more complex projectsOptimized apps all in oneIntrospection, 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 textExtensibility, elisp, communityextensible, 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.- Extensible - org mode - and other awesome packagesExtensibility, 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 modifiedEasy configuration, org mode, extensibility.elisp, 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 ExtensibilityExtensibility, performance and package system. And, of course, it's free (gratis) natureTimeless. 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 Codeit's open source the packages the flexibility/ability to customizeRange 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)survivalIntegration 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, interactivescalableshortcuts and packagesNative 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 freedomCustomizability via lispThoroughly 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,the power of the lisp machine (living code) extensibility (see point one) everything is a bufferIntegration 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, extensibilityCustomizability, DOOM, snippets, org-mode, 90s vibeCompletely 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 applicationsOrg-mode and the whole org environment, the emacs community, it's infinite customizabilityExtensibility, 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.Extensibility, text-editingIntegration 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 forwardEmacs Lisp, and how easy it the language makes it to hack every part of the user Emacs interface.Extensibility 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 functionsExtensibility, ecosystem (org, dired, magit), communitymagit, 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 ) Modesexpandability, the fact that is a system on its ownCustomizationsFully 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.Combining almost all my tools into one. Customizability that I can maintain and transfer easily.The way it rewards sustained investment.Extensibility, and some great packages by emacs 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 interfacekeyboard centric 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.Expandability; Every thing is "text"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.ExtendableCustomizability, 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 featuresIntrospection, and the customizable nature of everything.There's a core set of packages that are just stunningly powerful. Magit alone is worthy of an award.Dooms 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 use Emacs org-mode for note taking and task management. It's very powerful because of the agenda feature, tags, C-c C-c to run code snippets, and the many other features like setting the ordered property for tasks.It's ecosystem.I think the feature death the extensibility is pretty awesome. Every time I thought of something that I really wanted it to do, it couldn't figure out how, I eventually discovered it. Built-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)Plugins, lisp, extensibilityAllowing 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, eshellIt's extensibility and it's usage of LISP (specifically Emacs Lisp).The 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, philosophyThe fact that it's not a text editor but rather a text based UI, therefore combining the efficiency of a terminal and the greatness of modern software. I also love the values it represents, I think you notice how that shapes a project.Extensibility 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.maturity, introspectabilityThe 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.It's fully flexible and customizableExtensibility 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 freeIntegration of dev environment with packages such as org-mode and mu4e in a common text based paradigm.Lisp 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.high entry barrier leads to high-quality packages. the whole emacs api is well designed so all packages can neatly integrate into each other.org mode, extensibilityUsing emacs makes me a better technologists, through it and its ecosystem I keep refining the tools I use and discover new ones.Packages 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 packagesvhdl modeExtensibility, 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 and Keyboard Shortcutsextensibility,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.You can do everything with the keyboard + there are packages for everything.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)Integration of mail, editor and GTD- org mode - org-tree-to-indirect-buffer - flexibilityorg-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-modeBuilt-in "magical" features, so many packages/modes.Seamlessly used over ssh. Extensibility with a huge community of packages.Its extensibility and community.rich capabilities for feature extension; platforms to learn lisp programming; all-in-one text editing and org-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.Two things: Extensibility, and very accessible UI (e.g. M-x for commands).- Maintained by a community with no financial influence. - That it's a runtime with first-class lisp bindings and text and buffer primitives. The lisp bindings give me the ability to do anything (even use it as a scripting language), and allow meta-programming. The primitives are able to serve as good abstractions since so many things produce and consume text. - The length of time it's been maintained, and the steady hands that have guided it.- Elisps extensibility. - Easy to get started with Elisp - Community 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.being a semi lisp machineConfigurability. 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 melpaDoomPrimarily that it is free software. Both in that it's hackable and here to stay.Its extensibility and universality (“it’s an OS, not an editor”)integration of functions related to my entire development 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.Available on many platforms, long improving lifecycle, powerful, architecture, programmability, useful 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, configurabilityCompletely keyboard driven, extensive features via packages, light on resources, clutter-free UI, extensive configuration options, its fun to use.* loads of keybindings also valid in terminal (bash), which makes it easier than vim * programming language specific 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 machinesasdfIntrospectiveness, extensibility and "everything is text".Extensibility and Many PackagesOpen 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.Keyboard centrism, extensibilityThe 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 extendedOrg-mode, communityFlexibility, 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.keybind orientationCraftable 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 editorCustomizable & ExtensibilityIts ability to evolve and transform over timeExtensibility, Lispbuilt in lisp environment, org-mode, magitIt won't be killed by a company. It's extendibility.Emacs makes it learning and working fun while using.Packages, the ability to run on pretty much any machine, remote editing that just worksyour customizeIt's not an editor - it's a platform.Every 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 packagesI think that its greatest strength is file surfing and being able to manage windows with hotkeys. Oooo hot keys are great!It's flexibility; I wish more graphical and/or terminal UI elements could be more reachable in elispIts transparency, in the sense that the source of any function can be read and changed immediately.Integration, consistent experience, efficient workflowFreedom/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 modeflexible, lots of great packages, able to inter-connect different things / aspects of your life via packages written by the communityExtendability + 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 inIt automatically closes paranthesis and can display them in multiple colors And it has a cool git integrationKeybindings & 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.Extensibility, Customizability, FreedomReally 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.What are you using after Emacs? VS studioEmacs 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.Tweekabilityextensibility through elisp.Platform stability as a user. Emacs just gets better over time. If I develop a workflow around Emacs, I have confidence it will just work with minimal fuss.Extensibility, 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 - flexibilityflexibility many modes for programming org-modeExtensibility & 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 extensionsModifiableasfExtensibility, buffer representation and packages with unique paradigmsConfigurability: 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 packagesMagit. Good GUI while still relevant for CLI. Lisp. Doom Emacs.Programmability; and the ability to inspect the code and look up documentation for the code that runs the editor itself- Easy to extend and customize - Simple core abstractions allow great interoperability between packages - Larger packages that integrate tools into my development workflow: magit, lsp, ... - Small packages or features not easily available in other editors: projectile, wgrep, macros, ...Org-mode! Programmabilityextensibility & communityExtensibility and configurability.The help systemExtensibility, 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...Free, open source, very snappy, very extensible and customization with lots of shortcutsThe 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 pluginsExtensibility and that it is an OS.Its 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 supportOrg-mode, magit, now eglotThe 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 featuresExisting ecosystem of pluginsAbility 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, text formattingShortcutsEmacs' 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.The selfdocumentationthat 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 communityprogramme on pure textNon 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}28.229.028.127.227.126.326.125.225.324.325.128.023.124.521.424.126.223.224.220.024.4na26.0Spacemacs21.37nonemy special fork18.249.028.69I don't use Emacs25.0162.019.320.1whatever comes with the distrojust my bf's22.330.1I don't know, whatever is on my repos19.0?23.0Whatever is installed21.1223.14159219.3418.5928.3
Do you use any selection packages? Vector{String}VerticoIvyConsultHelmMarginaliaNoframework 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-keyfartsProbably moving to Verticoauto-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 whichCorfu, CompanySwiperfido-vertical-mode from IcompleteYesDOOMIcomplete-vertical (built-in)iciclesmy 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 NewsTwitterYouTubeYoutubeyoutubeI don'tfriendsSacha ChuaColleaguestwitterFriendsemacs-chinaHackerNewslobste.rshacker newssacha chuaMastodonHNEmacs Chinaplanet.emacslife.comTelegramnews.ycombinator.comFediverseepkgemacs chinagooglehackernewstelegramsachachua.comEmacs wikiHacker newsGoogle4chanHacker News (HN)Telegram chatI don’tdoomSacha Chua's Emacs newsLobste.rsI dontfediverseEmacs Wikiemacswiki.orgDebianemacs wikiPlanet EmacslifeSacha Chua's blogyoutube videosMeetupsDoomI don't use packagesEmacsWikimastodonemgSasha 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 EmacsN/ASlackcoworkersEmacs-Chinai dontEmacs-chinacolleaguesYoutube videos/g/describe-packageSacha 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 newsSacha 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, hackernewsDoom Emacs modules.Stackoverflowtwitter, emacs-newshttps://emacs-china.org/Sacha Chua's Emacs News (as linked from LWN.net)I don't - not keeping trackI suck at discovering new packagesStack OverflowDOOMlobste.rs news.ycombinator.comfreebsd forum, arch linux forum, hackernewsSasha Chua mailing listTwitter, colleaguesupgrade doom-emacsYoutube, word of mouthEmacs news - Sacha Chua#emacs tag on mastodonLooking 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 channelswishperEmacs Wiki, and on FediRecommendations from colleaguesdescribe-package with vertico completionsword of mouthUnsureI don't, reallyDo not really learn about themXMPP serversemacsconfemacswiki (why is this not an option?)Looking at the emacs config of other users in Githubi dont use emacsPlanet.emacslife.complanet.emacslife.com, Sacha Chua Emacs NewsI 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 NewsFriend/colleague recommendationsThe Emacs manualborgSeeing 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 / friendsA local community Slack channelemacs planetMy 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 channelsyoutubersEmacs News (by Sacha Chua)youtube channels like Systemcrafters, Distrotuberarely 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/I dont, not enough timeAccidentallySystem CrafterRecommendationSacha Chua's Mailing List (thanks Sacha!)Japanese community in slackSearching source and emacs git logsAptitude new packages listYoutube, Mastodon (social media)sachachua.com/blogssachachuahEmacs Meetups4chan'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 packageseXmppMastering emacs bookSpacemacs Gitter channelI dont really go looking for new packagesright now I am intentionally not seeking packagesSystemCrasters Youtube channelgooglingEpkghacker 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?elfeedDoom init.elCourse 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 twitterchat gptYoutube (system crafters is probably the biggest such channel)SystemCrafter'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 solutionDistro Tube, System Craftersguix searchnot actively looking for thatSystem Crafters youtube channelOften via EmacsWiki or general web search.Videos on LBRY and YoutubeNews.ycombinator.comSacha Chua's Emacs News blogI 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.Work SlackSacha 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 GeneralMy framework's package listlobster.rswatching YouTube videos on emacsstackoverflowxmppEmacswikiEmacs Weekly NewsEmacs News (Sasha Chua)emacs newspigeonsplanet.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 siteRarelyTwitter, especially Sacha Chua's weekly emacs news postsmasteringemacs.comTelegram 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 youtubesearch engineYouTube videos (Distrotube and System Crafters)Very rarelyYT System CraftersSystem Crafters, Distrotube etc youtubeI hardly look out for new packagesDoom's init.elstraight-use-package (keyword)Search engine when i find a deficient in emacsRSS feeds with elfeedSacha Chua! Thank you! Hugs!usenetSacha 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 StackExchangeIRCFrameworkMailing listsDiscordEmailMatrixDiscourseI don'tTelegramgoogleGooglen/aN/AI don’tnonei don'tNoneEmacs ChinaSlackI don't ask for helpI don't.telegramFriendsTwitterFediverseI dontfriendsweb searchColleaguesi dontsearch enginedon'tWeb searchMastodon-I do notEmacs-ChinaGoogle searchemacs-china.orgnowhereSearch Enginemastodonemacs-chinaDon'tNever haveemacs chinaWeb searchesi haven'tnotMy friendsslackSearch engine/g/searchI never haveDuckDuckGoNever didInternetSearch the webread the source4chanI don't askfediverseJabberNever had toblogs, web pagesWebTelegram 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 helpNeverI don't knownever asked for helpHaven't done itNowhereNever needed tonevercolleaguesSearchGitLabClojurians SlackTelegram chatXMPPStackOverflowduckduckgoWorkdocumentationnonaemacswiki.orgSearch EnginesI rarely doCompany 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 triedUsually 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.RSE SlackI don't ask any help, just give upCoworkersJapanese Emacs community in SlackI usually don't. Whilst I love the work of this community, it's a culture i prefer not to talk to. 10 years ago I said something that implied men and women are different in lisp IRC and i've never interacted with the community since.I 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 researchedReading the codeYouTube 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 myselfClojurians Slack communityNever 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 engineI generally don't ask for help unless I discover an issueRead 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 helpHaven't had to, mainly rely on preexisting queriestg 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 soUsually just (re)searchehaven'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.VariousI 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_ruIf I can't figure it out myself I'm most likely not using itAsk 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 silencelemmyemacs community inside my companyask friendsmatrixwork 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)manualsearching on the webI've never done thatemacs-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.FatherLocal Emacs communities or meetupsI 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 selfi read the source code and sufferright 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 workEdebugI just look around to see if someone has already asked on many of the listed places. I've never asked directlynever happenedHaven't yetNever happened so farDon't really ask, either it works or I need to read moreusually 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 codeI don't have a place to ask for help.First 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 toRead the documentationcolleagues 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 toI just struggle alone. I have no idea whynever needed yetJust search the internet.duck-duck-go searchLast resort is to read the code.i hack until my emacs system fulfills my needlocal community SlackI 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 helpMost of the time, I don't ask for helpBrowse the sourcegenerally I don'tI don't. I consult the documentation and the code.Don't botherMostly do not ask for help, that's what the source and documentation is forgoogle + 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 roomstackoverflowxmppNotboards.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.Online 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 elispasking for what?
How do you manage third-party packages? Vector{String}use-packagepackage.elframework defaultstraightmanualnot sureelpacaNixguixnixleafGuixquelpasetup.elel-getleaf.elGNU GuixborgCaskDebiannixpkgsDoomBorgNixOSapt-getGuix package managern/aaptSpacemacs layersDebian packagesdoomDoom EmacsSetup.eldebian packagesnixosNixosNix package managerparadoxQuelpapurcell's require-package (based on package.el)I don't use any.Doom Emacs as a frameworktrySimple custom use-package alternativepacmanleaf and Easkgit submoduleshome-managercaskStuff 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-emacsDOOMUsing nix in practice, specifically https://github.com/nix-community/emacs-overlayguix package manager, or elpaGUIX package managervia Doom's facilitiesstraight with leaf.elI don'tDoom Emacs manage for me.packages downloaded and added in my "init.el"nix-overlayuse 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, guixguix for installing and setup.el for configuringdistro 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 manuallyWhatever doom config does, not very knowledgeable here.what ever doom uses (straight?)Nix overlayI plan to use guixkeep libraries in Dropbox in git repos, load them with my own "package loader" macro. Too much breakage and dependency churn in package.el world (as of when I moved to this solution like 4 years ago)install 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)asdfnull - 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 macrosI use doom to manage packagesno 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 tutorialsI've been using package.el for about 5 years. I managed packages manually before that. I've just started with use-package.my 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-overlayhowever doom emacs does itwhat third-party packages?asp (AUR)I do not use packages anymoreguix package managerEverything in git(I used to do everything manually)Spacemacs 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-overlaybecause I use doomemacsmy new config avoids (nearly all) external packagesDoom emacsstraight.elspacemacsNix (with the "emacs-overlay" facility)will try straight when more comfortable with my setup.I've used straight but transitioned back to package.elM-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 packagespackage-vc
Which operating system to you use Emacs on? Vector{String}GNU/LinuxMacOSWindowsWSLBSDAndroidNixOSLinuxHaikuAndroid via TermuxOpenBSDGuixUbuntutermuxSolarisCygwinandroid via termuxITSLinux via TermuxguixcygwinnixosAndroid via termuxtops-20n/ai dont use emacsSolaris, AIXI run my OS in Emacs.Haiku-OSaix, solarisArchLinuxiOS via emulationandroid/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 ModeasdfManjaroGNU EmacsHurdandroidAndroid mobileAndroid (a little)ITS, Lisp MachinesArch linuxAndroid with termuxBusyBox/LinuxLinux via Crostini on ChromeOSGuix on top of GNU/Linuxmsdos0->1Windows with CygwinAndroid / TermuxCygwin, AIXhpux aix vms ...programming, bash, gdb, filesystem browsingDebian LinuxHaikuOSAndroid (via nix-on-droid)GentooOpenVMSAndroid (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 StudiogeditNeovimpicoViKateGeanyjoeGeditedBBEditNotepadneovimPicoNetbeansneditJoeKakouneTextMatejedRStudioTECOnvimceditNeditMicroEmacsjEditTextmatenotepadNetBeansMicroemacsvisual studioNeoVimbriefgeanyGEditDon't rememberUltraEditkakounePycharmBriefmicroemacsVisual studioVariousAcmeTPUJovejeditJedRstudioXcodeQt CreatorTextpadtecoVisual Studio 6Slick EditGeany, NotepadSOSedtKDevelopHelixHonestly can't remember, but probably "whatever was there" (often an IDE; Eclipse, Metrowerks..)variousMost of the aboveJeditQtCreatorturbo pascalkatepmate, microemacs, visual CEPMTextWranglerAuroraCygnusEdSpydernano, geditBorland C++ IDECan't rememberxeditnotepad.exePyCharmtexteditVSmicro emacsedlinMS-DOS editToo long ago to rememberpico, viMicro emacsI don't rememberHidemaruvi, not vimMultiEditJEDWebstormjoveMicroemacs on the Atari STlanguage specific idesKate, NetBeansThe built-in AmigaOS editorIt was 26 years ago, so I don’t remember, but definitely none of theseanythingwordstar I think? it was a long time agonano, atom, sublime, (devonthink on mac) and several othersVisual Studio 5XCode/Project Builderlogseq, triliumCan't remember that far back.Wordstarall of the aboveBBCodeEditraMix of Eclipse, Gedit, UltraEditvi - pre VimNotepad++, IntelliJ (NEVER AGAIN), Visual Studio (The GOLD standard)Gedit. But emacs was my first proper programmming editor.EDT(vms), XEDIT, vi --- vim was not available in 1993Pen and paper, xcode.UltraEdit-32UW pico (1990)BorlandSome Apple ][ DOS 3.1 text writertexstudioPlumaKate (KDE)various ancient editorsI use Vim, VS Code, IJNano, Emacs was my first good editormostly markdown editorsVisual C++Visual Studio, IntelliJ (WebStorm, RubyMine),Vim, VS Codevi (NOT vim. actual vi on actual UNIX))vi (not vim). MicroEmacs.Code blocksMatlabracketvis - https://git.sr.ht/~martanne/visNano, Katevi, Microsoft MTypora, AtomEpsilon Programmer's Editorvi, ed, edlinBorland's IDEs, Q editor for DOSsamwhatever I used back then, don't recallcant remember :)Borland Turbo C++Programmer's File EditorI mainly used Neovim and Kate.CodeWranglerNotepad (vanilla Windows)EdtDOS editWord, Notepad, meditEverything in the list accept AtomNotepad; edit.exe; qbasicmicroEMACSTurbo Pascal IDEDon't remeber; some MS-DOS editornano, pico, norton commander built-inMS-DOS Edit, Turbo Pascal, RHIDE, Delphitextmatevi (before vim)Whatever happened to be installed on the machine I was using at the time, with no consistency.Qt Creator, Vimed/qed/qedxVSCodiumEdt, teco, something on Prime OSTurbo EditOther - it was a long time agoedit.exe on DOSDon't remember ;)ultra-editorold Win32 editorVi and MicroEmacsIt's been so long that I do not rememberBorland / Turbo IDEsgedit, TeXstudioI can't remember.edit on dosultraeditdidn't really "have" an editor beforeZapvim & intellijBefore I started with Emacs, I didn't really use text-editors (or IDE's): For my writing work, I just used word processors (eg. Libre Office).atom, vim+tmux, vscodecan't remember, but I must've used them because I programmed thingsMultiple editorsVi. Vim wasn't around yet.Bluefishtoo many years ago to remember :)I still use the other editors: Vim, Eclipse, VS CodeVMS EDT, ed, viLyXlseTurbo Pascal; Micro Emacs (Amiga)intellij and vim for different languagestoo long ago to remembervi and XEmacsedt, eve, microemacs, forthxywriteNo main editorVarious IDEs depending on languageTurbo PascalProgrammers File EditorIDLEPico. (precursor to nano)TextMate 1.xNotepad, PicoxcodeTextEdit.app (on NEXTSTEP)Q (dos)uemacsSeveral different IDE's (Delphi, Eclipse etc.)NOTEPAD.EXESunview text editor, galahadWhatever came with the programming language and computer. Z80 Assembler, Amiga Basic, Turbo C/Pascal, Objective Pascal on Mac etc.vi and texedit (sun)Something in Windows. Delphi. Dunno anymore.EDT (on 1980s VAX)MS Notepadimacs on OS9JEditeditPyScripterKate. And before that Codewrite. And before that MS DOS Programmer's Workbench.I have never used Emacsed, DEC EDTVMS editorsVsCodiumCustom minimal editor, inspired by vijoe i guessbluefishgedit, notepadPico / nanoTECO, DEC EDT, Apollo DMnotepad, ultra editI am still using JOECombination VisualStudio/Emacs/EclipseJBuilder, DelphiMS-DOS Edit, Turbo Pascal *blush*some code editor for windows I can't remembernedit, vimcan't remember. I was on Amiga.Code Browser 4.9Pico on HP-UX, Borland on Windowsvi (it was before vim existed)some DOS editor, idkVisual Studio, Visual C++, EditPlus, Aurora Editor, QED, etc.VAX EDTPerfect Writer, or something like thatCygnus Ed (Amiga)geany; leafpad; notepadvisual studio, notepad++, vim, intellijVMS EDTacmeAlphaatom, vim, nano, npp, eclipse, vscodedon't remember, circa 1983Notepad, Borland c++C++ BuilderTurboPascal/Basic/etc.brief and others...not sure, Notepad?EDT (DEC's editor)EDTvi (vim wouldn't exist for a couple years)ed (modified by myself), turbo C, topspeed Cvim or IDEsdon't remeberPrimos editorTeraTermvisual studio/borlansDont rememberotherhidemarupycharm, atom, jupyter notbooksVS Code, IntelliJ, Eclipse, and a little VimIA WriterTextwranglerfeatherpadTeXStudiovi (pre-vim)asdf4coderword perfectPICONotepad, I guesssome old ones, can't remembersome weird pdp11 text editorEdEVE/TPUteco, epsilonMulti-EditVi, which is not vimElvisZmacs and GosmacsqtcreatorMicroEmacs (Windows)EM EditorQUED/M, Alphavi and an line editor developed by a university faculity.Multiple, each for different purposesoriginal viLibre Officeacme, samcan't rememberJoe, various Borland IDEsTried most of themVisual Studio (Not VS Code, _the_ Visual Studio)ed, MTS editorUltra EditVS6.0Don’t rememberReady to Programpico/nanoBorland, PicofteSlickeditIt's been so long I can't rememberUltraEdit on Windows (long time ago)don't rememberBorland C/C++Vi and micro emacsusing alongside vim!Zap on RISC OSXCodevi, nano, edit.com, borland IDEsPython IDLE/Dr. Java and similarSidekick (by Borland)any markdown editorVMS EDIT, Cyber FSEmicroemacs, old IDEsAmpMicrosoft Visual Studio, EclipseEverything available, no investment on anyI still use IntelliJ, 010editor, and others. I have used many, many other editors in the past.many different editorsnano/notepadpinknote padJupyter LabRHIDENotepad on Windows 98MSDOS EditVisual Studio IDEVisual Studio - plz shoot me :(TextadeptmatlabSpyder, QT studio, kilezileqedit/boxerC-lionVS studioepsilonobsidianMicro EmacsNorton commandervms editvarious IDE'sTurbo Pascal editor (DOS)gEdit (from IRIX)Many different onesobsidian and zettlrdiverseMix of Visual Studio, Eclipse, NetBeansWordEpsilontextwrangler for writing // zim for info-keeping //kate for codingnano, viEverything elsevi (no, not vim)Kate, mousepad, gedit, etcMS Wordwhatever was there 25 years ago on Atari ST or HP UXalpha on old macoscommercial editorDME on the Amiga/usr/ucb/viNone of the above existed back then. And can’t remember what I usedAurora text editor (MS/DOS)CodeBlocksI can’t remember :)CLionTeXmakertextpadborlandPascalApollo text editorPlain old VIdreamweaverjed and original viIDEs like Visual Studio, Borland. The vi version shipped with Watcom C for Windows.Borland C++Code::BlocksDefault editor on my host, probably nanoqbasic editorHomesitesublime text, vis, acmedec edirSome perkin-elmar stuffuemacs (IIRC), Turbo Pascal IDEHomeSite and Dreamweaver(multiple) RStudio, VS Code, Notepad++, I was sporadically using other software as wellHemlockvi, ed (not vim)i honestly can't remembervi, edtT602Various ancient text editorsTextPadVisKWrite/KateZetalisp, before that TECONotepad++, jedit, nedit, context and probably moreVMS EDT, VMS TPU, other ancient editorsMontgomery EmacsVarious Borland Editorsnone of the above, but I don't remember the nameVMS EDIT/EVE, BSD VIVi, mgAncient X11 editorsIDE (Delphi)MicroEmacs, now MGJoe, and many orhersVarious IDEVim + VS Code + IntelliJ + Atom + Notepad++vim/sublime/eclipse/etcWordStarVarious depending on language: pycharm, netbeans, sublime etcBSD vinano, pine, probably others...hard to remember, honestlyborlandMy journey has not been linear. TextMate, then Vim, then mainly Emacs in the last decade or so.Proprietary editorsMicrosoft OnenoteEditors that don't exist anymore (CP/M, MP/M, and other OS specific editors)VS Code, Sublime, IntelliJ... I think this should be a checkbox, not a radio buttonnvi as much as possible then vimKakoune (still using as primary)vi (original version)aeScrivenerISPFScintillaI dabbled with lots of them, but Emacs was the first one to stick.i tried quite a lot of editors (including vim, atom, sublime, gedit, kate) but doesn't stick with any in the long rundos vi clone, freemacs, briefMCeditProbably something weird on the Amigaedit80, ed, jmacs, zile, mg, origami, (n)vi, tempus, ...ed, vi, teco, ZmacsBorland c++VMS EVEAtom, Vim, and IDEsVim, KakouneTSONeovim. Still use it and prefer it over emacsBrief then notepad++Rand editorBorland CDevpac 68k Assembler?Some DOS editor I no longer recall.MicroEmacs, BBEditkdevelopauroraVim, VScode, Sublime Textedit.com from MS DOSDOS text editorsnotepad, DOS edittextedit (the default texteditor on unix at the time)vi, MS-DOS Editorvi (original)ObsidianTecoNotepad original windowsEm EditorNo preference beforeTen years ago, language specific IDEs (Eclipse, Arduino, XCode, etc.); nano for shell scripts; word processor for project notes.System's default, and alternate applications like LibreOffice Writer, TeXstudio, etcOverleaf, Libreofficeeditor bundled with IRIXkwriteJetBrain's IDE's + VS CodeEdit.appBBEdit, Xcode, MousepadTextEditoriginal ex/vimicroemacs, viScintilla, KatexyzzyXEmacsEmacs clones, DVEDKED, Teco (DEC)Vim, VSCode, Eclipse (still using them sometimes)Probably nedit on a hp-ux machine.qt creatormemacs!idlevi, MSDOS toolsThe one that came with Visual Basic, or Microsoft's Java IDE, depending on the language I was doingCrimson EditorBorland Turbo Pascalnano, notepad...VIPython IDLENano, PicoApple PagesmicroCode BlocksBusybox viNotepad++, Visual Studio, Eclipseall the aboveA fewKde kateKEditDefault text editor in my desktop environmentPEdit on DOSOld Visual Studio (from the '90s)FTEanything available, except vom (could not exit from it)Kate/Kwritevi before vim was a thingAnjutavi (older than vim)Visual C++ 6to long ago to rememberGoldED, XeditSublime Text, VS Code, VimDreamweaver,etcEither specialized IDEs for each language, stock distro text editors, or stuff in-between (Geany).RubyMinenotepad, visual studio, and picoCygnusEDTeraPadwordstar-like, Norton editorTextEdit (on Mac)Matlab editor, Fortan IDEsmicro emacs(on x68k)vi bbeditked (PDP-11 RT-11), variousTED (Atari ST)Notepad (1990s)Why can I choose only one option here? Strange question, as most people use multiple editors.so long ago I don't recall anymoreI use Emacs for note taking. I still use Vim for programming.pycharmR studioqt-creator, texstudioKomodo IDERexxThe Borland IDE, I think? Something on DOS.vi - pre-vim, afaikvim, tinkering with helixxedit,viCommodore 64
Do you maintain any Emacs packages? StringNoYes
Which of the following activities do you use Emacs for? Vector{String}Hobby projectsWorkSchoolEverythingUniversityStudyNote takingWritingeverythingPersonalschoolLifeStudiesEmailStudyingorg-modeNotesnotesNonePersonal organizationOrganizationOrgLife managementResearchPersonal useemailUniOrganizing my lifePIMPersonal notesJournalingwritinglifepersonal organizationuniversityAcademic studyGeneral useProgrammingKnowledge basejournalJournallingorgPersonal managementnoneSunday School notesPersonal OrganizationPersonal stuffall text editingPersonal lifeGeneral note takingNotetakingresearchlife managementbothstudypersonalAll text editingGamesEducationOrganisationtodos and calendar, mailorganizationHome Organisation, WritingScheduling & organizationEverything that deals with plain textNote taking in lectures and meetings, journaling, personal organization with org-agendaEmail, organization, etcWriting fiction - 8 published novelsStudies, general computing, journaling...MailsPersonal admin (org)Time trackingpersonal workorg mode personal stuffPolitical, welfare workLearning programming in generalDaily lifeJournaling. Note taking.Everything that is textpersonal information managmentResearch, Notetaking, Journalling, Time Management, Mails and ScreenwritingLearn Web developmentMatrix communication,email communication, system maintainance (daemons, systemd-mode, etc).Terminal and code editorpersonal organization (org-mode, sysadmin tasks)FOSS developmentNotes - orgOrganizing my plans with orgEMACS IS MY LIFEAlmost everything related to a computing environmentDaily productivity (email/mu4e, news/elfeed), personal information management (budgeting, order tracking, &c./org-mode/org-edna/magit-mode)Desktop manager (Exwm)Personal information and tasksLife Management / Project ManagementEmail, IRC Chattingeveryday use, mail and so onNotes/TodoI use vimMostly org-mode is what keeps me coming back to emacs.Research and learningNote Taking, Routine trackingPersonal Management: org-mode for TODOs, denote for knowledge management, ledger-mode for personal financeorganising everythingPrivate CalendarNote taking, writingPolitical Organisation"Power Tool"general note taking, and organizing as wellnote-takingorg-mode journalabout everythingOrganize lifeEverything!blogging,writingschool/academiaOrg onlyTurning lights on and offSchoolworkKeeping track of interesting things I learnacademic papersjournaling, time management, basically everything i can fit into itPrivate todoswriting short storiesKnowledge management systemPersonal notes & learninglife organizationuniversity, notetakingTaking notes with org-roam; as password manager (org-crypt); etcExpenses, note taking, password and information management, bulk file renamingpersonal stuff (in org-mode mostly), not related to programmingKnowledge ManagementNews, emailStudent workletter writing, journal, mail, etcWriting, Organizing, ...Most text file editingwriting a bookpretty much anythingcollegePimpersonal information management in private life, and to support my wifeä businessNix local system config editing, org mode occasionally (but switched to obsidian for a while)personal managementPrivate life with Org-modeTODOsMost thingsLearning/ Knowledge ManagementWriting fiction and blog entriesEverything that involves writingTask managementAgendacreative avoidanceAll journaling and todo listsManagement of personal aspectsPersonal computingorg-mode organization of all lifeLearning Lispeveryday thingstorrent client interfaceerotic manga viewingNote TakingAll situations, including studiesPersonal information managementknowledge-base w/ orgHomemail, file management, interaction with the OStinkering procrastination toyLifelogStudy (PhD)telega (because it's the only desktop client that supports secret chats)Leisure and entertainmenti dont use emacsWhere I can , work hobby and otherwisePersonal dataaccountingMagitPersonal organisation (org-mode etc)Notes, Agenda, Email, RSS reader, etc.General organizationlearn lispLife admin, MailHome organization, personal finance, personal projectsWriting papers.To multitaskAnything I canLife in generalAcademiaNotebook and agendaEvery task in my PCPersonal businessStudying, GTDHomework (previously)I don't use EmacseffluviaOrganising my lifenotes,mail etcPretty much everythingEverything I can do in itAcademicLiterally most computing tasksTo-do listsgeneral note-takingWriting, NotetakingMaintaining personal org filesTask keepingAlmost any activity that has to do with editing text.Personal UsePlanning/noteswriting essays, document outlines, string manipulationall text processingEmacs as a front end for almost all daily activitiesHome lifePersonal planningPersonal organization and schedulingBlogging, Email, Window Manageremail, accounting, etcToy editororganization and studyingBlogging, personal record keeping, writingTodos, tracking my life, magitORGasdfNote, agenda, bloggingbloggingScheduling and emailNote taking, personal knowledge management, personal finance management, contacts managementpersonal useEmacs is started at startup and always open. I use it for all text files unless when Emacs struggles such as when line too long, and dired (rectangle edit is good). I use Emacs because of Xah Fly Keys.Activism, Life, the Universe, and EverythingDaily life managementNote taking (org-mode)Software developmentTask organisation, scheduling etc. Personal information management.contacts, calendars, wikis, notes,Home task managementPersonal email and all non html text wranglingTeaching religious lessonsFiction writing; bloggingMy own desktop, for anything digital with EXWM/org-mode/org-roam/notmuch as my main driversall things plain textStudentWriting and maintaining my todossexClassesHome stuffI take my personnal notes, and organisation on itprivatePlanning & OrganiaztionCollege (undergrad)Switching to VimNothingPersonal organization (org-mode)Chez SchemePretty much everything, including all email, text writing, and any other tasks involving symbolic manipulation.Day to day notesalmost everything that does not requiere me to use an IDE for specific stuff.allI dunno if my hobby is workIRCAlmost everything that requires writing textPersonal orgresearch, teachingExperimentI do not use EmacsPersonal activitiesPlanning, journalingpersonal info managementPlanningUniversity StudyPerosnal, e.g. notes with org-modeStudent WorkPersonal (diary/calendar)Self-organizingXml editorAlmost everything I write text or code in.University projectsMainly everything...personal knowledge managementDay2Day tasks/OrganizationOrganizing Lifelistening to music, reading emails, taking notes, accountingWindow Managereverything writing and organizing realtedLife! (Org)University courseOrganizingStudy in universityTracking personal itemsOrg mode for knowledge bases and projects trackingHousehold bookkeepingpimAgenda, personal wikiFree software developmentPersonal notes (Org Mode)School. Everyday life (email, news, social media, time management etc.).Studying, coding, task-trackingPersonal knowledge managementEverything elseTaking notes (personal/class)PracticeSchool/ResearchOrganizing my life with org modePersonal note takingnoteeverything I need to write/edit texts etc.ALL THE THINGS! ALL OF THEM!All personal projects habits etcPersonal Information ManagementHome and school window managers.note taking diredchat, email, rss, journalingAt the moment I'm mostly using Org mode and Magit. I'm on myTracking personal to-dosacademicsGeneral Text EditingCalendarNote taking, org-modeTaking notes and Org-roamorg-mode notes for my entire lifeStudy NotesD&D note-taking in org-modePKM, agendaHome/Personal ManagementJournaling, GTD, knowledge gatheringLife, PKM, GTDmaintanance of my operating systemNotes/org-modeMail Bibliographynotes taking, math, music, videos, ...Personal financetexto editingpretty any text editingFunCommunityuniveristyAll my text editing needstask management, writing, news reading, for work and personalPersonal agendalife organisationAlmost Everything ;)personal life organisationPersonal accounting, organizationediting, usenetmail, feedsEmacsTraining, Email, FinancialThe grindI no longer use Emacs. I switched to Vimanything text baseduniversity projectsToo many things :)RSS,organization,system configPersonal accounting, personal calendar, personal organisationOther private stuff that is not a hobbypersonal email and filingdaily lifePersonal - organizationWriting, planning, information managementPersonal notes and tasksjournal, tasks, training routines, calendarGetting Things DonetimetrackingEVERYTHINGKnowledge management, note takingPersonal infowriting proseJournalPlaying gamesUniversity Degreestill lerning and not productive with itInterface; Android Launcher via TEL and EXWMLearning to codei dontLife organisationwhenever I need to write something downjournaling, writing (stories)just about anythingLiving ;-)Pretty much everything except web browsing and instant messagingPleasuring myselfPKM, GTD, email, WM, etcjournalingHome lab automation etc.As a frontend for mkshExoBrainRecipe PlaningComputing Environmentusing my computerLeisureTinkeringPrivate Lifepersonal use, public projectsPersonal administrationHome - orgmode for tasksstudiesdaily computing needs.Everthing computer related: music, email, file manager, video manager, notes, password manager, etc.take notesorg-mode (GTD)Org modefamily choresEveryday lifenote taking , gtdpersonal stufflife and general stuff (org, gnus)e-Maileverything can be done in EmacsWriting, Publishing, Calendaring, As text-based interface for interacting with other systemsNote captureuni work and notesAlmost everythingmoney tracking, task tracking, time tracking, note takingPKMNotes, schedules (private and business)General document editingJournal, Ledger, PMK, Programmingall personal organizationI basically live in emacs & brave/chrome for everything.With Org, long-form writing, knowledge management, task management, project trackingKeeping notes in org modePersonal information systemschool workchattingboyfriendDaily EverythingPersonal org mode useSchool notesOrganization and GTD (via org-mode, of course)Using terminals only in emacsAlmost all writing, info managementLearningPlayingMy InformaticaLISPM/PDP-10 hackingPersonal configuration of my system.University (notes, problem sets)Almost all text editing; also automating processeshome everythingwriting blogsprosePIM and LoggingText editing in generalInformation Managementnote taking and financeNotes ETCAs many things as possibleTask ManagementLedgerwindow managerpersonal knowledge management, TODO system, CollegePrivate projectsOrganisation, Note-takingflexorg-mode for personal useWriting, web publishing, diary,Everything (EXWM)learning to codePKM, dotfiles management, taking notesSchool (CS)dev
Do you use an undo package in Emacs? StringNoundo-treeframework defaultundo-fuvundoundo-redoundo-fu and vundoI don't knowC-x uC-_Built in undoGoto-last-changen/aThat's another thing. Emacs doesn't even have undo/redo ... WTFI prefer btrfs snapshotsNo. I hear corruption happens with themno, but i have it in "TODO" :)redo+Spacemacsvundo, undo-fuevil-undoI use the built-in undo.I use the default with a long buffer of previous cut text.undo-fu, undo-fu-session, vundoundo-propose-ido-completing-read+I don't know which one I useI use vimI use the default undo (a lot)Dont knowWhatever EVIL usesframework, but "undo" is what I really do *not* like about Emacs -- too many pitfalls/data lossC-/Built-inwinnerevil undo I thinkundo-tree with undo-fu-sessiondont knowsimple.elUndo-fu on Emacs 27 and less for commands. Vundo for tree in all versions.Just regular undoWhat's an undo package?dunnoIs "undo" a package? I just use ctrl-_; is this the default "package"?undo-redo from evildefaultThe default (undo-tree?)evil undo-redowhatever "C-x u" gives memeowgood question. I should look at thisundo-tree but rarelyundo-no-redo t and undo-redodon't knowC-/ (built-in undo)Winner mode i think it is called?Just a function to go backwards in the killringBuilt injust C-x uundo-redo (builtin)Emacs builtin undoboth undo-fu and vundoplain undo
Have you signed (or attempted to sign) the FSF copyright papers? Stringnever consideredmight in future0-2y10+y2-5y5-10y
Which theme do you use? Vector{String}doom-onemy own custom thememodus-operandimodus-vivendidefault lightdefault darksolarized-darkgruvboxdraculasolarizedzenburnnordef-themesmonokaileuvenwombattango-darkspacemacs-darkdeeper-bluewheatgrassdoom-one-lightdoom-norddoom-vibrantcyberpunkspacemacs-lightdoom-tomorrow-nightdoom-palenighttsdh-darkmisteriosoadwaitasanityinc-tomorrow-nightnanodoom-tokyo-nightmanoj-darkdoom-molokaiMonokaimaterialdoom-dark+spacemacsdoom-acario-darkLeuvencatppuccindoom-moonlightdoom-draculatomorrow-nightatom-one-darkef-biomoe-themeafternoonspacemacs darkdoom-spacegreytron-legacykaolin-oceandoom-horizonsanityinc-tomorrowmonokai-protangodoom-themesdoom-oceanic-nextsanityinc-tomorrow-brightdoom-old-hopematerial-themesanityinc-tomorrow-daydoom-challenger-deepmoedarktoothdichromacysanityinc-tomorrow-eightiescolor-theme-sanityinc-tomorrowsanityinc-tomorrow-bluebase16zerodarkdoom-earl-greydoom-snazzyNanoef-lightCatppuccinabyssacme-themedoom-Iosvkemdoom-laserwaveef-darknano-themedoom-acario-lightef-nightcyberpunk-themechallenger-deeptokyo-nightef-daydoom-city-lightsSpacemacsdoom-1337tsdh-lightvscode-dark-plusdoom-miramaredoom-ir-blackgruber-darkerdoom-sourcererdoom-ayu-darkNimbusnano-darktangotangoblackboarddoom-outrun-electricmolokaideep-bluelight-bluetwilightdoom-gruvboxflatwhitedoom-homage-whitedoom-wilmersdorfpoetCyberpunkdoom-flatwhiteTomorrowdoom-operadoom-monokai-promindrespacegraycatpuccinayuspacemacs-themeef-autumnkaolindoom-ayu-lightbadwolfalect-darkdoom-monokaioutrun-electricmaterial-darkWheatgrassalmost-mono-creamtomorrowkaolin-bubblegumacmemoe-darkewal-doom-onestimmung-themesef-deuteranopia-lightMaterialdoom-spacegraycolor-theme-charcoal-blackbase16-heliosgruvbox-lighteverblushpalenightwhiteboardinkpotword-perfectunderwaterhumanoid-darkkaolin-mono-darkflatuimonokai-themeef-themewilmersdorfef-wintervscode-dark-plus-themealect-blacksolarized-lightdoom-rougetao-themedoom-tomorrow-daykaolin-themesdoom-tomorrownaquadahgothamTango-darkkaolin-templekaolin-darktaoSpacemacs lightdoom-peacockinfodocmonokai-darkparchment-themeI don't rememberkaolin-galaxykaolin-auroraMisteriosoample-zenspacemacs lightatom-darknimbusdarculastimmung-themes-lightexoticaEf-themesaalto-lightdoom-xcodeone-darkSpacemacs-darkCustom darkWombatmoe-lightsanity-inccatppucinflatlandrebeccachocolatedoon-nordef-themes, modus-themesyoshi-themeMaterial-lightplan9acme-nofrilsef-themes, lambda-themeslambda-light-fadedef-theme (ef-dark)doom-ewalcolor-forest"theme"?Xdefaultschanges oftenample with customizationsEf-Themesbespoke-theme darkgruber darkerAyu-mirageNano, tsdhleuven, monokaiayu-miragedoom-shades-of-purplevs-light and vs-darknoctiluxdon't remember and why is this a mandatory question?TransSidedefaultmy ownnano + kaolin-templegrayscale-theme.eldoom-solarized-lightdoom-wilmersdorf (lightly modified)monokai darkDefault theme with --bg darkslategrey3 and --fg wheatSpacemacs defaultBrutalistbrutalist-darkmadhat2rhc-zenburnvarious doom-* and spacemacs-* themes (both light and dark)default spacemacs themetsdhfeng-shuiuwu-themedarktoohef-*Anti-Zenburnanything dark from doom-themesSpacemacs themeDoom-oceanic-nextVarious ef-themesspacemacs themeNagatsdh-light, tsdh-darknone-ef-deuteranopia-darkKaolin-galaxycalm-forestNord light, catpuccin frappedark themes from ef-themesvariesProt'sSketch-themesDoom-draculamultiple other themesa default theme, but not sure which onegrandshellhumanoid-themesThe default. I don't even know if that means light or dark, and I don't care.Atome-one-darkemacs -r + some customizationsapropropriate-darkalect-themescustomized dark theme from netA dark base16 theme.modified zenburnDark manojno theme, my terminal provides the colorsef-tritanopia-darkVarious, usually lightef-autumn from ef-themeszonokai-bluepaper-themedoom-homage-blackDon’t recallalmost-mono-whiterandom dark themetokyo nightchallenger deepvs-darknimbus (custom)something darkWhen I feel bored by modus, I'll switch to ef-themes for a bitI use the circadian package, which changes the theme based on the current time. My circadian config uses 7 different themes : kaolin-light, doom-flatwhite, doom-solarized-light, doom-miramare, doom-dracula, doom-tomorrow-night, and doom-rougeklereAtom onedoom-monokai-restrettovimspectrcustom, but dark backgroundhoberKaolin, tokyonight, ef-themesatomdoom-{tomorrow-night,manegarm,Iosvkem,badger,rouge}Kaolin-darkdoom-city-lights, doom-horizoncobaltNano-theme (light)vs-code-dark-themespacemacs-dark or doom-challenger-deepatom-onepoet-darkshades of purplebespoke-themes(load-theme 'wombat t)gotham-theme, tron-legacy-theme, ef-tritanopia-darkdoom-oceanic-next in doom-themestwilight-anti-brightNot really a theme, but loose customizationsample-flatdoom-alabasterTty user defaultCarlosone dark atomDeeper-blueI think I added something to .emacs like 20 years ago that made everything dark. Is that the dark theme? Probably not, but it works, and I'm used to it. On macOS, I still do invert-face, default every time I start Emacs (once a month, at most, I normally use Emacs on Linux).base16 based Nordsolo-jazz and gruber-darkercatppuccin-frappegruvbox-darkmaterializeddoom-any-lightdefault light w/ green strings... red should be for errors ONLYdarkokaidoom-lanternmontzmonokai proDoom themesgnome2spacegreyef-frostef-cypresdoom-novabased on high-contrastAlmost-monotao-yin (dark)doom-material-darkI don’t knowstandard-darktheme generated by pywal using wal packagedoom nebulavscode-darksanity tomorrowmoe-dark, cloudThe beautiful and well-crafted ef-themes, which are also developed by Protesilaos Stavrou.doom-palenight, gruvbox-lightef-spring, ef-winteri have no idea lolnano-modeHoneydewas specified by starter kitcustom variant of deeper-bluecustomized misteriosoef-summervarious doom themessanityinc-solarized-dark (slightly modified)sootheDarktoothmisteriosioBase16acario-lightalect-lightdefault black from 256Afternoondoom-homage-oneMy own (catppuccin)Darkokaione-lightuwubase64-eightiesef-themes (currently ef-night)One of the blue onesoutrunsanityinc tomorrow nightWhite-on-black or amber-on-black glass tty emulationgreen on blackFrequent switching based on mood and time of dayauraLeuven darkVarious themes simultaneously in different frames, all darkcustom nord, spacemacs-darkAcmezerodrakdoom-flat-whitewhatever matches my current desktop themedoom-opera, doom-opera-lightadwaita, leuvenef-themes autumnmoonlighttwilight-bright, monokaileuven-dark, almost-monoEf themeszen and artflatui / challenger-deep (switching via theme-changer)ef-themes (ef-spring)vscodemy own brutalist theme (light variant), and occasionally nano-lightleuven (I think it's called)doom-material-dark, kunagawaorangey-bitsdefault; not sure if it's light or darkSpacemacstarlitmoe-theme adaptedModified doom-one-lightmodus-vivendi with non-default options and 1 custom faceturbo visionef duo-darkMy own dark thememonokai-pro-octagon, flatland, timu-spacegreycustomized leuvenbase16 eightiesSpacemacs themesothertango darkcharcoal-blackdeeper bluexcode darkcolor-theme-sanityincNot sure about the visual one, but I make use of the 3d sound theme from Emacspeak.base256Gruvboxcustom themeGrangerLeuven, Zerodarkef-duo-lightsanityinc-tomorrow-blue, sanityinc-solarized-lightAny dark themesome random doom themeWhat a stupid questionhttps://github.com/djcb/dream-thememonokai, tangonov, leuvengruvbox-light-hardfont-lock is disabledCatpuccino, monokaisuneaterchallenger-deep , wheatgrass , tango-darkWhatever Prelude shipsNone im using emacs in the TerminalhorizonJonathan Blow's emacs themedoom-monokai-classica customized molokaibase16-material-darkerAtom-oneCustomized wombatdoom-palenight (even though I don't use doom), and I secondarily alternate with doom-nord-light depending on light conditions, or doom-Iosvkem.reykjavikbillw, purple-haze, leuven, feng-shui, matrix, goldenrodThe defaultNo fancy colors nor fonts, like Xah.lambda-themesparchment, materialnano darka modified "cyberpunk" themeeink-emacsSolarized-lightBase-16 brewermaterial-theme-oceantomorrow/material themesdracula-pro van-helsingleuven, misteriosoample, alect, moedoom themestdsh-dark, tdsh-lightdoom-nebula, doom-nordmy terminalMisterioso and whatever fits my mood that dayfaffspacemacs defaultef-themes, minsk, purpi've used several and amended a few but for now a fan of modus.Spacemacs' default dark themehighly customized zenburnef-themes and doom-themesvibrantdoom-wilmersdorf, doom-acario-lightCustom Sweet-Dard themedont careidea-darkuladoom-badgerOwn lightspacemacs-light,spacemacs-darkdoom-modelineThe spacemacs light default.Dark+vs-code-dark-plusDark+ from doom themespok-wogJbeansone of the dark ones. PS: PLS make the default a modern dark interface, it is retarded white which burns eyes the same as this page :Dbase16-monokaiDoom-peackokdoom-nord-lightI still use wheat on darkslategrey that I started with on RedHat Linux 5.1.Jetbrains darculair-black (not 100% sure)I use simple themes I have modified myself. Mainly light, but occasionally dark (dependent on lighting conditions).deeperblueplanetunsureemacs -rvleuven-darkbillw, charcoal-black, clarity, dark-laptop, desert, goldenrod, gray30, hober, jsc-dark, railscast, simple-1, subdued, birds-of-paradise-plus, darktooth, dracula, nord, pandasolarized-selenized-whiteWhiteboardI use vimdoom-tomorrow-lightOne-light, atom-one-darkdoom-meltbusNonematerial themeMonokai and Auroracant recall, but vary from time to timemoe-dark & moe-lighttao-themesCustom dark theme.I switch between modus-operandi and doom-ir-black with a function that runs on a timer (i.e. day/night theme)doom-monakaiDefaultNone, I do not use any form of syntax highlightingselenized-darkDoom one lightmonakaiminimal-themespacemacs theme, kaolin themedome-one-lightNowhichever one fits my current desktop themeMonokai proYour themeSpacemacs light/darkPaperColorI don't knowkaolin-themes (kaolin-valley-light)Charcoaldoom-one-light with customizations to make comments more saturatedbase16-apprenticecolor-theme-sanityinc-tomorrow-nightsanityinccustomized tsdh-lightcluestommyh-themecustom dark themeDoom challenger deepdoom-gruvbox-material-themeMy ownVscode+none, the terminal is themed alreadyThe doom family (especially solarized)?Don’t knownotinkinkpot, nano, draculahave to tweak solarized darkbase-16base16-tomorrow-night-eightiesAcario-light, hennaDon’t rememberjbeansselenized-lightjunioLluevendoom-opera-lightef-themes-load-random(use-package darkula-theme)color-theme-sanityinc-tomorrow-brightbase16-chalkleuven-themecommentarysolarized-light-high-contrast, humanoid-light, spacemacs-light, doom-solarized-lightDoom Tokyo Night with some of my own personal color overridesAmplesomething else, but I don't remember right nowdarkest-midnightsolo-jazzemfysculpture-themes-darktango dark - as I am blind, this is not relevant to me.not suremy dark themeLambda-themeset foreground-color background-color etc in default-frame-alistChangesdoom-sourcerer, doom-tokyo-nightSanity-inkatom onesoft-morningI use the nowindow emacsianyepan/acme-emacs-themebase16-grayscale-darkdoom-tomorrow-day, doom-tomorrow-nightayu-greylight-rock something?Spacemacs Darkcyberpunk with some modificationseink, cyberpunkmoe light/darktango-dark?Ujelly, and some doom+ themesDoom-palenight.emacs sets the colors to green text on black background no opacityI don't use a themesanityinc-tomorrow-eighties, doom-laserwaveEmacs default theme (that is, no theme selected)Nano lightPeacockicebergjazz-themeDoom-Tokyo-nightI just rotate all of them with load-theme. But, I do not like dark-themes the most. It is not a pedagogic theme at all. And it is a "fake" showing off hacking culture without a rationale. I suggest Emacs devs to consult experts in colour and education to create a pedagogic set of themes for teachers...Sanityinc Tomorrow Darknord-auroraspace-greyKaolindoom-one-light, and sometimes also doom-spacegrey or doom-miramareoceanic-nextmodified doom-molokaiPlan9misterioso and wombatbase16-themeSpacemacs, tomorrow-nightsanityinc tomorrowmaterial-lightI don’t rememberdisable "color crap" -- high contrast b&wmodified nyx-theme and hemera, with circadian.elspacewaymy own custom theme forked from monokaiI am red-green-colorblind and prefer high contrastdoom-one but with black backgroundef-cyprusIcebergalways something new, e.g. now ef-themessome tron one i just picked upRebeccaCustom theme inspired by doomCustom Star Trek TNG-inspired one which accidentally makes rainbow-delimiters look dull but I'm too lazy to fix itdoom-oceanic-next, tao themesdarker-blue, adwaitaFogusdakronemolokimood-oneSpacegray,moonlightCatppuccin Mochatarp-mcfaypandaSpacemacs dark and lightSelenizedGothamRougedoom-themes and ef-themeshipsterdefault light with light green backgrounddoom-one-light, doom-palenightDunnoTokyo night since Catppuccin isn't updated yettwilight-brightI change themes frequentlytangotango darkMaterial-darkChanging all the timeheavily customized zenburnDoom-tokyo-night, doom-moonlight, doom-palenight, doom-horizon, doom-laserwave, doom-oceanic-nextbase16-atelier-forestDichromacydoom-nord-auroraclassictomorrow-night-brightplan9, owldefaults + (progn (set-face-foreground 'default "white") (set-face-background 'default "black"))The tinted variants of the modus themesir-blackhemisu-darkIt depends on time of day and preferenceModified green-phosphorparchmentwombat?My own theme is a low-contrast light themeHumanoid darkspacemacaheavily modified "elegant"vimdefaultspacemacs-light, spacemacs-darkDoom-tomorrow-nighthorizon darksuscolorsTerminal themei dont use emacsspacethem-lightsolarized-selenized-blackef-themes one of the dark onestango lightTokyo-nightGruber Darkwhatever prelude usesef-theme light version; earlier I have used slightly customized default light theme.almost-mono-graydefault spacemacsnone (green foreground, darkslategrey background)a dark, colorful thememidnight-bluesolarized-dark heavily tweakedCustomTaoEf themeCustom theme without syntax highlighting for textSpacemacs darkdoom standardbase16-eightiesMonokai ProujellyDoom-homage-blackDon't rememberGrandshellappearance versus realitynano-theme-lightdark-emacsjust swapped background and foreground colorsone cclose to the old xemacs lookdoom-dracula and doom-gruvbox mostlyjedit-greysanityinc-tomorrow-darkTao themeI change them depending on the lightning conditionsclues-theme.elForgot namekaolin-eclipseDoom Acario Darkafternoon-themeSlightly modified dark+different one every weekLight modescyberpunk-something-or-otherdoom-nord + doom-early-greysrceryef-tritanopia-lightMy framework's dark thememonokai/molokaidoom-tommorow-nighttango-pluswheatgrass (with enhancements)seti, whiteboardtabak-themelight theme (zen)nord-lightLots of others, but lately they've been causing Emacs to crash, so I only use solarized.underwater variantI cannot find a command to show the current theme's namenight-owl-themeef-night,ef-frostI switch themes very frequently, at the moment I use kaolinkootentwo custom themes, dark & light, + glue to switch based on system-wide dark/light settingsanity-inc-tomorrow-eightiesyou might be spending too much time in emacswhite on blackacme and tao, both with font lock disabledcustomI don't care about themescatppuccin-mochaNano darknano-emacs lightel-themes (ef-bio)black backgroundjbeans-themeatom-one-dark-themeMaterial-darkerLeuwenin constant changes, can't settleleuvan-dark (i think)nano-lightplan9-themeef-day, ef-winterTangoMultiple dynamic themesdoom-monokai-pro / ef-themesdarkburncobalt, spacemacs-lightBorland bluedoom-gruvbox, solarized-lightXresources theme so it matches my terminal emulatorslightly modified versions of different dark themes.labburn-themehttps://emacsthemes.com/themes/ir-black-theme.htmltomorrow nightewalef-themes, wombatSanityincmy custom is dark.with some adjustmentsEmacs has themes? I just take the default and set foreground/background to nice light/dark colours.All sorts of doom & base16 themes.autumn-lightacme-emacs-themepoet-dark-monochromeA light one I can’t remember!Doom badgerothersoceanicnextdoom-materialdoom-Iosvkem with some customizationsDoom-1337Lambda light fadedterminal color schemewith customizationssorcery,orange-retro,nano-light,nano-darkSpacemacs default darkef -themestango dark?goose
Which package archives do you use? Vector{String}MELPAGNU ELPAframework defaultSourceMELPA StableNonGNU ELPAnot sureGNU ELPA develGuixDebianguixGNU GuixnoneNonenixpkgsNixOrgquelpanixgithuborgNixpkgsn/aorgmode.org/elpahttps://orgmode.org/elpa/Debian packagesemacswikiGitsearch with MELPA, download from GithubMostly rebuilding packages myself from scratch because a lot of them are _terrible_ quality and bug ridden/orgmode.org/elpa/Don't know what a package isGuix, NixI don't use any.EmacsMirror/Epkgi dont use emacsNonGNU ELPA develguix package repoDoom Emacsorg-mode.orglocal custom package mirrorNix emacs-overlaymirrors hosted in China mainlandguix and other third parte channlesNone, fully manualNone.Debian repoOperating System PackagesEmacs wikigit via use-packagethe Debian archiveORG mode https://orgmode.org/elpa/used to do other things, but Spacemacs is the right LOE for me nownone? whatever comes in debianMy GNU/Linux distribution's package managerborgwhat ever is available by default in doomOccasionally build from gitI use vimDebian aptwhichever guix pulls fromWhatever Doom usesUsing vanilla EmacsNo idea what those are really. ELPA/MELPA just sounded good.Whatever doom config does, not very knowledgeable here.however doom emacs does itemacs-overlaySee answer aboveGithub with quelpaOrg modeI clone repos from wherever they live, as I want them.jcs-elpapkgsrcI do not use packages anymoreI plan to use guixel-get (github, emacswiki, elpa)Org-mode ELPAI really don't care. Doom has set it up and it finds the things I need.none, I use git repos in DropboxWhat Doom's doing :)Multipleuser42, TheCyberShadowofficial Debian packages (sudo apt install elpa-...)Guix onlyasdfpersonal guix channeleclecticQuelpa to download from git reposCompany curated archivedebian repositoryemacsmirror (i.e., build from source)Debian's elpa-* packagesTrisquel packages only ATM..again with the idiot zoomer belief of how things should be done... =_=Debian, GitHubOrg elpa.pkg.tar.zstpackage archive provided by coworkersWherever Nix gets them fromdoomnix emacs-overlayBuilt from source using NixNo package archive available at workOrg Mode's package archivecustomdebian reposel-getNix packagesdebianhttps://github.com/nix-community/emacs-overlayDebian repositoryguix that use some of the aboveI use doom emacs so straight i guessmaybe something is installed from elpa but I'm not sureMy own local archive created with https://github.com/redguardtoo/elpa-mirror to keep a stable set of versionsThe defaults set by Doomtromeydebian packagesdoom emacsMarmaladeQuelpaChinese ELPA and MELPAInstalled from my GNU/Linux distribution's repositories (Debian)built from source (my own audited forks)none/all (only for metadata via borg.el; I don't really build package.el packages)org-modei don't use third-party packagesAll those Spacemacs accessesdistro packages (debian, nixos, guix)User42: https://user42.tuxfamily.org/elpa/index.htmlgit
Do you use Emacs for writing prose? StringFrequentlySometimesOftenRarelyNever
Which languages do you program (in Emacs) in? Vector{String}PythonShellElispCHTML/CSSJavascriptC++RustSQLGoTypescriptClojureCommon LispSchemeHaskellJavaRubyPerlRPHPAssemblyElixirJuliaC#ErlangScalaLaTeXFortranOCamlLuaNixRacketNonenoneOcamlVerilogPrologZigSwiftLatexF#KotlinElmVHDLocamlAdazigAgdaDartluaorgMarkdownfortranRakuTeXscalaCoqMatlabTerraformIdriscommon lispHCLnixPurescriptlatexNimdartDBashPowershellLeanTclorg-modeFennelswiftkotlinXMLOrgadaTCLSystemVerilogverilogPureScriptOrg modeSMLLispNot a programmerJLua, FennelSASCrystalGDScriptjsonnetForthTeX/LaTeXMATLABvhdlmarkdownOctaveJsonnetgroovyAgda, CoqrackettextCommon lispOctave/MATLABSwift, Objective-CMakeQMLterraformOcaml, CoqbashSageLilypondmatlabHaxeCFEngineagdaYAMLPuppetnimN/AGuileSolidityDart/FlutterPowerShellFORTRANI don't program in emacsnone yetAPLYamlTerraform, CloudFormationScala, Wrenverilog/vhdl/systemverilogn/aLatex, SAGEWolfram LanguageenglishCoq,Dafny,F*,MakeBash, SPARQLAll of the above and more, I exclusively use emacs for programming taskstclAppleScriptConfiguration files, org modePrimary tool to open any fileXquery, XsltMaude, BQN, MinizincJSON, YAML, Dockerfile etc.EntropyNix, Zig, Scala, basically anything I usepurescriptGraphviz, Markdown, YAMLSystem VerilogYAML, MarkdownEnglishLatex, RacketOCaml, Coq, MichelsonMarkdown with pandocFORTH, System VerilogLua, CrystalYaml. Salt Ansiblelatex,texinfo,makefileStataVBAjavascriptBrainfuckLaTexGroovyI use vimScala, DartStandard MLahkInformMarkdown, TerraformLua, CMake, TeX/LaTeX/ConTeXtansibleI use it for all of the languages, unless Emacs can't work with a specific/large projectXML/XSLTReactJaiNo programming, orgmode onlySnobol4Emacs lispRacket, SMLPlaintextSAS, Godot-ScriptIdris 2some others (as hobby)Prolog, ScalavariousOcaml, Coq, LaTeXLaTeX, MatlabCoq, TLA+none, just use orgscala, gdscriptorg (kind of serious here)Kotlin, Odinit's impossible to be efficient with ts without of vscodeOnly text notes to myselfLaTex, povrayi dont use emacs to codeVerilog,tcl,hareStandard ML, Nix, Markdown, GeminiVerilog, TclHareS-LangAgda, Nix, Zigno knowledge of languagesOCAMLproprietaryObjective-C, awk, bashNiche and self-made langaugesEmacs Lisp, GNU APLI'm learningTerraform, JsonnetNone at the momentKiXtart, LuaMarkdown for pandocVue.jsAWK, m4, LaTeX, AutoHotKey, Applescriptlua, gdscriptEditing data filesLatex, othersDart, Tclmarkdown, latexNim, GDScript, NixTonnes moreI only use it for Org ModeI don'tI use vim for codingCMakePascalOrg-ModeLaTeX, Stataall languages I programm unDockerNim, FortranGleamText and schedules in Org modeRacket, XMLXSLT, XQueryRescriptreact.js vue.jssystem verilogPlain text :-)common-lispVhdl systemverilogLaTeX, Agda, IdrisAWS CloudFormation, Ansiblevarious DSLspicolispMy own little language tooMany, including very small languages as PL nerdScala, NixFortran, LatexI only use emacs for org-modeI don't use Emacs for coding.orgmodei dont use emacsI don't use it for programming anymoreNo oneocaml, common lisp, elm, purescriptObjective-C, SwiftOCaml, Agda, CoqAWKSwift, KotlinMagitTexInform7org-mode, markdown-IsabelleRaku, VZig, nim, nixOCaml, HaskellI stopped coding in EmacsCommon Lisp, Jdo not use emacs for programmingI am not a programmerAnsible, LilypondClojurescriptFORTHI don't use Emacsx64, C and Go in edOnly inside org-babel: python, elispNo,just org modePine ScriptScala, PL/1, MacLISP, MAP355 assemblersml, latex, orgCoq, AgdaPurescript, nixMaxima, OctaveHCL/TerraformI used to program C++ and C# on Windows professionally. I sometimes used Emacs for that.Common Lisp, lua, and other lisps like fennelnonUse emacs for magit and diredNot a programmer, just latex, markdown and similarOCaml, CoqI try not to use emacs other than elisp, using vscode for other languagesRpm specOCaml, ScalaHTML, CSS, SLIM, etc.Forth/FactorNowadays just org, swift hopefully soonORG mode, plain textsome latex, but mainly I use it for org roamIEC61131 Structured TextI use vim for programmingidrisLua, Vlang, RedasdfObjective CoctaveNot a programmer, i use org-modeXSLTCommon LISPLua, groovyTerraform, Ansiblemultiple proprietary languages (work)Scala, ammoniteyamlCLURacket, OCamlXQueryAHKZig, F#, Nim, CrystalEmacs Lisp, LuaElm,XSLJSONNone - I only use it for prose4glVarious IaC like docker, helm, cloudformation, ansible, makefilesI'm not a programmerNix, LatexCLI use almost for writingOCaml, LuajanetUse it mainly not for programming but Gnus for mail, org, taking notes, …Amxx pawnasciidoc, yamlprolog,mercuryFortran, RacketDylanoctave/matlabVuePascal, lua, zigTcl/Tk, Batch scripting, MATLAB, LaTeXAnsible, TerraformJanetcurrently; mostly common lisp, I have in past also used the aboveRacket, OCaml, LaTeXOrgmodejson, RESTbrainfuckNote taking and version control via org mode and magitaplOrg, LatexElm, Standard ML, FutharkRobot Programs (FANUC, KUKA, ABB, etc.)solidityLaTeX, Fortranverilog/system verilog/bluespecraku, zig, k8s manifests/yaml, nixorg-roamplain textTerraform,Groovy,MarkdownNone, I'm only using Emacs for prose at the momentOberonNim, SystemVerilog, MATLABnone, text in orgmodescala, jsonnetAnsibleLua, Dockerfiles, basically all text files, and sometimes for non-text files too.scala, nixVerilog, VHDL, Yocto recipe filesplenty moreArcLiquidunison langCoq,OCamlGAPDon't program in EmacsCOBOLPowerShell, GDScriptopenScadHare, ZigVerilog, SystemVerilogCommon Lisp;Coqall and my ownNix, Guile, Purescript, Janet, Scala, Agda, Common Lisp, Elm, HyGuile, NixConTeXtLilypond, ZigHCL, YAMLFutharkSo very much XML and JSON. Please let it stop.HCL, Terraform, Dockerfile, Jenkinsfile, K8s YAML, human-readable readmes Markdown documentation, notes taking, automate OS executables configuration and automatic upgrades, Git diff/commit/rebase, diffing, automate repeating string manipulation on files, Bash programming, writing Research Thesis, CV/Resume in LaTeX, writing UML sourceKotlin, LaTeXMakefilesystemverilog,verilogCamlObjective C, Swift, Io, SmallTalk, TinyScheme, Squirrel, markdown if we're including markup languages...OCaml, Tcl/TkEshell, BASIC, SpinKotlin, ElmBQNmake, bitbakeJqGNUCOBOLgdscriptProlog, BQNEnglish prose onlybeancountI don't use emacs to write computer codeWASMLua for WM configI basically only use Org ModeMatlab :'(Some of those choices checked maybe not attempted yet.Racket/Many Other Languageslua, fennelCythonorg modeObjective C/C++, Swift, Verilog, Makefiles, TCL, Lua, and I'm still probably forgetting at least a half dozen.F#, OCamlm4Salesforce ApexI only use org-modepostscriptOpendylan, Fantom, Purescriptbat,OpenSCADNone, I use vimlilypondGMPL or AMPLOrg-modeANSI Common LisphoonMathematicaNix, HCL, Nuyaml, json, toml, etc.nomore dialects of lisp, PrologV, JanetCoq, Idrislua, latex,VHDL, LaTeXDart +Flutterheex (elixir markup)ledger journalTerraform YAMLSvelte, VueUse vim for programingAgda, IdrisFORTRAN (but not recently)no programmingMakefilesOCaml, SML, PrologYANGTLA+GDScript, FennelNo languages yetOrgModeWGSLelmNix, OCamlTerminfoEverythingNone. I find it not satisfying regarding the refactoring features even though lsp exist, comparing to what exists with intellijTCL, Coq, makefiles, Matlab/octave, ld-scriptsBlitz Basic (using my own major mode)... specifically Guile ;-)LaTeX, RacketFactor, LuaNote-takingOCaml, F#LaTeX, DEiffel, LaTeXMacaulay2and all other languagesVariousJ, KLaTeX, MDOctave, WolframlangScala, StarlarknowebShell scriptsnote-taking?Swift; LaTeXNix, bashodinProgramming is one thing I prefer to do outside of Emacs.Zig, AdaBrainfuck and LuaVerilog, VHDL, tclConfiguration FilesStandard ML, OCamlCiao PrologHAML, YAMLSwift, Objective-C, YAML, HCLcudanone, just using org-modetexforth, tclI use emacs for everything, although TS language-server itself makes Emacs heavyLaTeX, postscriptlatex and org filesOCaml, Idris, Elm, Coq, Markdown, YAML, JSONbash, yamlKotlin, Dot, LaTeXfennelDocBookmuahahacorporate internal languageAPL/BQNMs powershell :shrug:Lua, LaTeX, Maxima, AgdaNix, Zig, WolframObjective-CI am not a programmer, this is very sporadic useSvelteWolframSuperCollideri only have coded with p5js, processing, html/css, ruby... mostly for one-off websites and for public art projects - i mostly use kate for coding. i want to learn lisp/scheme/racketelispterraform,cloudformation (YAML and HCL)HySolidity and Cairo (StarkNet)None. Only use MagitAda OCaml Nim ORGTerraform, YAML, other configLearning common lispHCL, YAML, TOMLsagemathI want to get started on elisp beyond .emacs configs. for instance to create filters and access to data sets and external algorithms like gpt3Lua, ZigLaTex, bashOcaml, HackMarkdown, RSTproseOpenscadSagemathGodotorg-babel languages (bash, shell, python, gnuplot)I don’t programLua, Common LispLATEXMIPSvhaskellLedgerProprietarypascalVJDLI d0n't programI program in VimI do not program in EmacsreStructuredText, markdowngraphviz, plantuml, mermaid
Did you respond to the 2020 Emacs survey? StringNoNot sureYes
Do you use a project management package in Emacs? StringNoprojectileframework defaultproject.eltreemacsmy own, mostly via perspectiveorgmodecounsel-git??package integrated with my employer’s internal systemsprojectile but I often question whyI created my ownptd-project (I wrote it)Both project and projectileI use vimCustomTreemacsDoes org-mode count?I think I use projectileI liked projectile, but have my own custom onehelm-projectileperjectnot really activelyboth projectile and project.elAda mode projectsself written packageJust what consult givesboth project (because of eglot) and projectilenixphiUndo-treeagain this is on my list to look into sooonishhhlspThe standard project C-x p pNot yetNo idea what that ismy owna simple custom context loaderjust realized there is a thing.desktop+project.el and a custom backendspacemacsBoth project.el and projectileborg.elMy own weird custom oneHave not yet explored, due to lack of timeUnreleased Personal HackWould that make my computer a manager?Perspectiveorg-modeLeafGNU Guix manifestsprojectile and project.el
If you rarely/never contribute to packages, what are the main barriers to doing so? Vector{String}Elisp proficiencyLack of timeLack confidence in code qualityUnfamiliar with contribution processNot knowing how to modify a packageNot interestedFSF paperworkWariness of the review processBad prior experienceNo needsocial anxietyno needEnglishNot necessaryLazinessMy employer's policiesrarely see a needHave not encountered a blocking issue to fix, alternatives were availablelack of ideaI usually am happy with the packages I use. If I were not, I'd uninstall them.It's so easy to fix things for myself I may not be motivated to share the results.My changes are usually not widely applicablenot needed toCorporate paperworkI usually don't have anything to contribute to the packages I use. More often than not, they do what I want them to do.Not able to work on open source projectsHonestly, I've been turned off by the attitudes of some greybeard emacs wizards when i tried to engage.Lack of bugs or other annoyancesA lot of packages are stale or less-than-actively maintainedThe community is terrible and nobody likes working with open source software people (they are insane zealots who have no concept of quality or accountability), I am not being paid to be someone else's QA, engineering, and support teams.Usually satisfied with feature setOlder packages can seem very complicated, not actively maintainedmost packages work perfectly for my usecaseSetup of tool chaîne and testednot that much is brokenI use plain vanilla emacsWorkflow for locally testing my changesTbh, the packages I use daily are already rock solid.Haven't had a problem I was in a position to contribute a fix forLack of stuff to be improvedOverwhelmed by package number, alternatives, possibilities, lack of confidencerarely have issuesdoing much volunteer work outside emacsit's rather trivial or too complexI use vimlack of time/interest -- fixing problems locally doesn't always make it upstreamNo need (I'm usually happy with how it currently works).I only use tried and tested packages that, on the whole, work fine.I submitted a patch to another FOSS project and someone else wrote their own version of what I did and called my patch unimpressive. Probably for the best to do my own work and let the real programmers do their thing.No idea how the overall package system works compared to others like pip, npm, cargo, etc.I just ain't got the time.The feature is good enough and it can satisfy me. In addition, Emacs has provided lots of functionalities, and I almost use vanilla Emacs. Therefore, my configuration file is relatively small.need to learn edebugit mostly just worksnot knowing how to get a package development environment set upfixing it myselfover customization of emacs has always been fraught with problematic behavior, i prefer to keep minimal configuration to directly serve editor purpose.i avoid packages that need hacking to work wellI barely use themBasically just use syntax highlighting packagesEmployment agreementI tend to use mature packages & built ins.They work well enoughquelpa sucks, no other trivially easy way to install / work on a package. especially a package that you use one version of already.slow response from maintainersi use mature packages that seem completenot discovered any hindrances, yetGenerally satisified with packages as they areLack of trust and too much time spent alone, waiting for the world to meet me halfway but people like their trenches.Packages are already so good that I don't need to contribute---seriouslymany packages are maintained by unfriendly neckbeardsPrefer developing new packages that I will release later onNot knowing package goals and concept of code disign, bad issue trackingPackage has all features I need without bugs.I'm still a fairly new user and lack any knowledge of elisp.Not a programmerrarely meet problemsSocial anxiety (being honest)Poor English language skills and poor knowledge of the necessary Emacs terms.Not knowing impact of changes on others (lack of safety from automated unit test suites)most packages just workAnxiety, and timeLately, I haven't seen the need to modify the packages I use. They do what I want them to do.I don't use them.Elisp code is very difficult to reasona about and refactorMostly happyEmployer restrictionsnot confident that contributions are wantedAlso I don't dwell in areas of Emacs' weaknesses, so not much to improveNo need; they workDon't often find something I want to add or fixfew problemsCan't figure out how to use mailing listspatch be emailsMy chances are typically tweaks to match my personal preferences being what can be done through official config, and aren’t complete or generic enough to be helpful for anyone else.I do not use gitI'm still new and haven't learned how to do soI don't care.elisps is crapNo M$ Github accGenerally they work so well, not a great neednon native english speakerI think I do not use anyNIHShynessmailing listPackages mostly workUse github pleaseNot had any need.Mailing listHonestly, there's so much great stuff I don't see what I could reasonably improve.too old, not a proficient coderPackage complexitylolWork contract makes it difficultHackability based on Lisp extensibilitythey just work, and i dont need more featuresThe package works without issuesNot needing to, few bugs.Don't have much to work on really.Not knowing where to startThe mailing list is worse than githubEverything is fine alreadyNot sure my customizations/changes would be useful to othersLack of ideasNot to bother maintainermost packages work well enoughRarely neededI'm only a hobbiest and I don't trust my codeUnfamiliar with the internal code of how the package worksI tend to only do things if I would like themthe emacs ecosystem and workflow is a big unknownnot yet on that proficiency levelNo issuesElisp preferences of package authorsprivacy concernsNever really needed tonothing to doLack of packages that I find interestingLegal approval to make contributions from employer takes agesGPLv3 is crazy complex and including 'or any later version' is a concept that allows me to sell out my firstborn for any ideology of the fsf in the futurethey are good enoughLittle reason to, most packages I use work very wellPackages are matureI haven't had an idea for an improvement yetNever encountered any serious bugsmost packages workI am such a newbie - I have considered helping with documentation or even learning basic code stuff - maybe i should?Not sure how to maintain a local fork that won’t be overwritten by updates in the meantime or by full .emacs.d wipes. Also disfamiliar with GitI typically have trouble installing packages so contributing is a reachDon't have a concrete needOnly contribute when there's something that is really bothering me about a packageRarely have the need to contribute. Only rarely if there is an obvious bug in a package I use.Did not consider it yet (my bad)Don't generally have strong ideas about how packages should be changed/improvedNo need tod do so.Don't use packages, nothing to contribute, metaphysical error.Those packages have already met my expectation.prioritise projects over configuring tools for working with them... :)non pull-request/merge-request interface (as in github/gitlab)In some prior contributions, patches can take very long to get a first response, where in that time I'm just endlessly waiting, and I don't if the patch is good or not, I just wish the maintainers gave me a quick estimate if it looks good or notI rarely run into any problemsIm new using emacs and not have now enough knowledge, but i hope start contributeSeldom is the package important enough that I need to change it. Either I use it as-is or I don't.packages are sufficient, rarely (never) encountered bugsmost of the changes I make are too customAlready high qualitySome of them sites like Github that doesn't work without running its proprietary javascriptno barriers; there's nothing I'd like addednothing meaningful to contributeThings work well. I haven’t needed toNo need.Often I am implementing things that I dont think many would find useful.Don't see a need; most packages do what I need them to doLack of documentationIt's a bother to talk to people.most of the time the packages are good enough for meUsually things just work and don't require fixesNo idea how I could contribute when stuff Just Works^tmIt's rarely neededRarely ever find something lacking, and if I ever do I can write a function for it.Maintainers fix problems extremely fastThe packages I use are generally in working order, and most of the changes I want to make are specific to me.I'm too stupidUnsure of testing processesTime it takes for maintainers to replyenglish is not my mother languageneed to fill out paperwork at work for each new projectAfter having got features I wanted integrated, the packages I use work for meI don't know how to go about diagnosing the issue most of the time - the only real issues I've encountered have been crashes and soft-locks.no need, they workNo issues with packageMost of my changes are custom and unlikely to be useful to othersgenerally only use robust packagesNot understanding Emacs internals enoughI'm usually satisfied with how they workI dont have a problem with what i am usingnon-native speaker, afraid of grammar errors within documentationmailing lists are very cumbersomepackages work wellI know enough Lisp to understand enough ELisp to write things, but compared to CL it's like shoving sticks under my fingernails. Or at least that's how I remember it, it was a while ago.Gonna have a go soonMaintaining my own versions with my patches. Sometimes, uncooperative maintainer or too much delay before getting answers. Usually eleminating packages that are not high-quality.Never had an issue that I was able to fix myself and shareI'm a new userFor features, my use-case is very specific usually and I just replace/adivse functions. For bug-fixes, I will fix it and contribute ASAPNever had a reason toI don’t generally stretch a package to the point where I’d find something I want to enhanceHaven't written a lot of production-quality Elispdon't use that many packagesEverything already works well enoughFeels like building on unsteady groundI contribute to my own packages onlyshynessFor the mature package like Magit, I think it's good enough. For the packages need lots of works still, I have no free time and passion to do them.rms' beardMailing List has more friction than GitHub PRI usually get it to work on my machine and worry about contribution later. Often what I want is either super personalized or already in PR.since employer has copyright by lawI usually can work around issues, or install an alternative packagestuff i use works good enough for me.High package maturity, no contribution necessarynew joinerThe quality's already very good, so I don't find many problemsN/A haven't needed toHave my own projectsno need toStarted using Emacs recentlywanting to make a better pacakage altogetherHaven’t needed to/spotted the right opportunityFinding an entry point matching my skills and interestsI don't usually need toNot sure what I would contributedon't use packagesLack of time and I rarely see the need, as most packages are more than decent.I am usually able to work around it locally (in my own config)Lack of need; I haven't found many problems.Can seldom reproduce problems relevant to othersit is much easier to hack something together sdecialized for my own use case than to stay within the package's aimsHave not needed to fix anything yetI haven't needed toPackages are often so well written that there isn't much value I can addI have not felt I had anything to addrarely run into issuesDon't know what a package isnot knowing package internalsJust never been needed as far as i can telleverythings is already here :)social anxiety disorderChanges suit my needs specificallyDefault behaviours satisfy my needsBad communication skillsI'm not doing fancy stuffsA lot of them are in github which I refuse to useGiving my copyright to FSF (I do not want to publish legal name and address)Haven't had cause to contribute (yet)introverted as fuckbad internet accessBeing a studentnetwork is blockingtoo much of a curmudgeonI don't really run into bugs/missing features all that oftenI'm still learningSeldomly run into bugs. :-)NO issues to reportWarMailing lists are awful as compared to a central issue trackerHate dealing with mailing listsWriting commit message gives me a headachePackage Maintainersgreat quality of packagestoo beginner to know what I'd want to add or modify, I still just learn stuff mostlyLanguage(I'm not use english)Never had the needMostly using stable packagesToo much of my own work to get doneI generally stick to fairly mature packages that work good enough for meMaintaniner's lack of time to help me throughnot many ideas of contibutions to makeI find things to already be fairly stableToo shy.I contribute to other things with code mostly and for now I not find an oportinity... or the oportunity don't find me.Lack of need. Most of the time, things just work, so I don't need to touch them.It works alreadyhave not find where to improveI've been using emacs to learn other languages so that maybe I can make my hobby pay one day. I'm not there yet.Can't find things to contribute. Or the issue is too hard for me to solve.project hosted or discussed in proprietary or walled garden (github, discourse, slack, etc.)I do not use packages anymoreJust still pretty new to emacs!IgnoranceI am a very old noobUntil recently, work restrictions on open source contribsMost things works already quite goodI have nothing to contributeI rarely find anything to improve in the packages I use.No ideas for improvementsNot sure anyone else would be interestedNot used to a mailing listGNU CommunityHaven't encountered a need yetLack of bugs to fixA lot of stuff, ... just works. So there is rarely a need to contribute.Most of the things I need just workThey work fineI wish there was a clear consensus on how to structure unit tests for elisp packages during the brainstorming phase of kicking off a new projectI'm rarely interrested to work on others programs (sadly). I could fix simple things like bugs, documentation but I've not had a real need yet.Don’t have to very ofteni don't find there are things that need much improvement in emacsPackages already doing what I needNo need so farMost things work well enough that I don't need todidn't see the need yetEmployer prohibitionI mostly make changes to my local setup and then I'm happy. It's not always relevant to others.my email is disorganized. process seems email heavy, and I have no experience participating in mailing listsI don't have anything to add to the packagesThey already do what I needLanguage barrierit is for my own interest & usefor built-in/gnu elpa packages, having to exchange patches over emailNot sure how to set up a dev environment for emacs packages.native languageLargely haven't needed toNothing to contributeContributions just being ignoredUnwillingness to use githubI'm just new to the editor!Emacs should be on github. The cost of dealing with a non-standard contribution method isn't worth it. I just want to open a PR.Generally satisfied with package quality already.I have checked paperwork, but only because any fix I would submit would be 1-2 lines long not something substantial. Actually have an issue currently with one change to org-mouse.el which seems broken when executing agenda targets from context menu on never org-mode/emacs.FSF bigotrybeing able to work around issuesCowardice
How well does Emacs perform in your experience? StringGood but not greatVery well, it's snappyAlrightNot wellPoorly, it's sluggish
What is your gender? StringMaleFemaleNon-binaryNonbinaryNBnon-binaryotherAgenderNon binaryNon-BinaryNon BinaryXnon binarynanone of your businessn/aDemigirlspace roboti dont use emacs/irrelevantenbynonbinaryOther? Really?Male for professional purposesBiogically male, I don't identify with my gendernoneNot999Feminine leaning non binaryI use vimfuck this questionThere are no othersnongenderqueerGender isn't important to mePansexualT1000gender questioningAttack helicopterPrefer not to sayOtherTrans WomanbeasthmmKamov Ka-52 Alligator attack helicopterN/A
What is your nationality? StringUnited States citizenAmericanGermanFrenchChineseBritishIndianCanadianSwedishBrazilianRussianSpanishAustralianPolishItalianDutchJapaneseFinnishNorwegianAustrianDanishEnglishBelgian(other)SwissUkrainianMexicanHungarianTurkishArgentinePortugueseSouth AfricanCzechIrishGreekRomanianIsraeliTaiwaneseIranianNew ZealanderChileanCroatianColombianBulgarianSlovakScottishVietnameseSerbianSouth KoreanFilipinoLithuanianSlovenianEstonianIndonesianWelshVenezuelanLatvianPeruvianHongkongerAlgerianThaiMacedonianUruguayanBosnia and HerzegovinaNepaleseBolivianSingaporeanCypriotIcelandicCubanGeorgianBangladeshiMoldovanUzbekIraqiMalaysianDominican Republic citizenBelarusianKyrgyzAfghanAlbanianKazakhPakistaniEgyptianEthiopianMauritianLebaneseMalagasyGuatemalanPuertoHaitianSalvadoreanMoroccanCostaNigerianArmenianBurmeseSaudi ArabianKenyanTunisianGhanaianLuxembourgerChadianDominicanSomaliOmaniMalianEmiratiCongolese (DRC)StatelessBahrainiSyrianParaguayanRwandanVatican citizenCayman IslanderMongolianNorthern IrishCameroonianSenegalesePalestinianJordanianBritish Virgin IslanderUgandanEcuadoreanAndorranEritrean
How do you interact with the shell in Emacs? Vector{String}eshellvtermnoneshellshell-commandansi-termtermmulti-termmulti-vtermcompileeatcotermbetter-shellevil command modemultiterm:!org-babel shell code block executionCan't rememberbut if I did, it would be eshellcomintmulti-term if necessarymost often than not, I use a real terminalmulti-term usuallybut rarelyeshell for some quick things, but for the most part I don't use the shell through Emacs....but I want topipertclsh, sqliteshMy own wrapper around `term' that fixes some of the flawseepitchshell-popAweshellWhatever comes with eMacs preludeterminator inside Emacs since exwmexternal item2 window tbhMulti-termOrg-mode shelcompile, async-shell-commandold custom function to use shell/eshellFork of shellshell-command-on-regionEmacs-nshI wish I could more but the options all seem to not make the cutM-&Konsoleeat-eshell integrationAll emacs terminals are horrible, maybe async-shell-command is usableI don’t as they are often buggy or I’m breaking the buffers somehow, also much much slower than any native term.Choicing is too confusing.Thanks! I did not know about "term", but it does seem to work reasonably well.I use vimI usually just ctrl-z out of emacs when I need a temrinal and fg back inOrg-babelin most cases I use a separate terminal window, but I do use vterm and pipe through shell-command as well.DiredThe options are really badM-! and M-|async-shell-command,dired-do-async-shell-commandI spawn a terminal from emacs which starts in the corresponding dirvterm is annoying with its lack of current-directory integration, but it's the best we gotssh.el (thank you noah)begin_src shhaven't had the time to learn eshellCustom function to send region to async shelli don'tI tried, it was terrible, so I use regular terminal now.detached.elorg babel bash blocksCustomizedeaf-termorg babelM-! and shell-comman-on-regionTmuxM-|Org modeC-z; ; fgawe-shellevil-mode's ex mode ":!"Not sureterminal-hereNot consistently enough to use oneM-x shellPrimarily use dedicated terminals.rloginpersonal extensions to comintM-x shell is usually the first command I enter. I always do shell CLI in shell-mode.M-x compileVarious, but often outside emacsnot sureshxwanted esell but wasn't productive immediatelyemacs-libvtermI like vterm but don't install it typically. Would be nice if something like it was included in emacs.vterm-multiasync-shell-command with popper.elI only do accidentally with shortcut keystrokes. I do need to actually learn to use it.compile-commandMy own terminal: "Eat" (I wrote it.)I try different emacs shells from time to time, but always just use an external shell instead. Habbit I guess.compilation command and bufferEXWM+TilixI often try but love my kitty too muchI almost neveraweshellpowershell hacknone of them work all that well thoughI rarely doshelldonscreen (via eshell)nav/termCustom shell frameworkshell, but very seldomI have heavily extended comint. Use it constantly.I use a keybinding to launch a external terminal ( ex:- kitty)async-shell-command (to avoid blocking exwm)Have not yet explored, due to lack of timeuse shell on a separate windowcmd in WindowsScripted to execute current linewith a custom elisp layer on shell-modeKonsole (for Muds)vterm-tmuxst in exwm, because ansi-term is incomplete and sloweshell is good, but should have more vterm capabilities...I use xah-interactive-shell-abbrev (probably old name, old code), it's "Prompt to insert string from alist.". I save command lines in the alist that i use often.async-shell-commandorg-mode babel code blockI only use this rarely, but would like to use it more.counshellTend to rather avoid it thoughM-!Org-babel src blockscompilation-modePoorlyWhatever the default isWhatever the default on my Xubuntu distro issome helpers calling wt.exejust by using compileevil-ex-shell-commandIt has been some time, so I am not sure that it is shell, in any case it has a prompt
Which features keep you using Emacs? Vector{String}Package(s)ExtensibilityText editing featuresBuilt-in featuresCommunityPart of the GNU project / FSForg-modeOrg-modeorgorgmodeorg modeOrg modemagitLispOrgFamiliarityOrg ModeMagitEmacs LisplispDoomDoom EmacsDocumentationInertiamuscle memoryhabitSLIMEOrg-Modeelispmu4eCustomizabilityLongevityevilPortabilityinertiaCiderOrg mode, magitLISPmagit, org-modedoom emacsevil modeNoneMuscle memoryStabilityMalleabilityorg, magittrampElispslimecustomizationOrgmodekeybindingsorg-roamFunHabitLisp supportLSPCIDERkey bindingsI am used to itAccessible themesi know more commands in it than vimevil, GUI, org, projectile, vterm, doomn/acommands embedded in muscle memoryorg notmuchhabit, familiarityThe fact that all of the above in brought to bear on extending my capacitiesit is awesomeheritage of LISPspacemacs / vimelisp environmentdriving from the keyboardorg-mode, nothing is impossibleGood cross platform supportSpacemacsIt's comparable to a LISP machineFor being a classic desktop, with end-user programming concept and full integration of anything. I have one integrated mind, no reason to work on a single desktop, an exobrain, with sealed comparments or at maximum copy/paste as IPCsGraphic renderingOrg related packagesfreedomWritten in lispnot rmsProgrammingorg and magitStockholm syndromeorg, org-roamSLIME/SLY, Magit, and my cripping muscle memory of Emacs keybindingsevil packageBidirectional supporteverything is a bufferOrg, Lisp-related packagesI use vimThe All things in One place feelingmagit, and force of habitI have been using it for so long I don't want to use anything elseOrg Mode, Org Roam, DoomIt just... Feels right. No other editor just feels this good to use out of the box.Org-Mode, Evil-ModeGUI and terminal versionsAvailable in every distro repointertiaelisp extension languageorg mode, magit, overall ergonomicsmostly habitsmodes (perl sgml xml html+)Clojuremu4e, orgcl package, use loop macro all the timeMagit/integration with the operating systemlongevity of the softwareMagit org vterm slimehopeMagic, orgemacsclient / emacs daemonREPL based work flows and literate programmingmagit, orgmodeOne editor to do everything, and wellSelf-documentedAvailable even on terrible operating systemsorg-mode, verilog-mode, python-mode, c++ mode, helm, magit,lisp basedThis question is badly phrased. Freedom + extensibility -> the other choicesthe way it makes me thinkdir, file, buffer local variables and inertialibrecross-platformUXUtility for both writing and programmingSlime (common lisp)Its open and libbresunk costForce of habitIntrospectabilityIts what I knoworg-mode!ability to have a integrated computing environmentC-x C-s is in my muscle memory now.Long-term stabilityIt's my desktop manager tooCross-Platform Interface to the ComputerskkstubbornnessThat I never have to use the mouseORG MODEorg mode, LSPInteractive configurabilityBloggingOrg-mode (the main reason I couldn't leave before really starting to love it)i don't actually knowminimal interfaceMy brain only knows Emacs nowtelegaEvilMulti-platformTRAMPDocumentation and helpBest software ever made !longevityfront-end(e)LispDonald E Knuth uses it.gui and no gui optionsKeybind!!!!i dont use emacsDude, I don't use it.It's libre software (not the same as "Part of the GNU project / FSF")Reliable, full of features, stability and spartanic beautyIt's not locking in my data to a cloud-based proprietary format with a subscription fee to access it.org-mode, magit... DOOM (eases configuration headaches)keyboard-focusedLearning lispself-documentingmagit, slime, ssh.elUsable without a mouse pointersly/slimeLisp magicEmailIt works in a way that I likeDOOOOMCoolnessOrg-mode, LispBuilt in Lisp programming languagekeybindings (make editing documents really fast)I have tostable and perfect user experienceTRAMP, eglot, xref, magit, counsel are the killer packages for meI don't use Emacsgreat mechanism for interfacing with CLI tools like they were part of emacsNone, I use Vimkbd macrosI've built a custom text mode for a large project of my own.Vim supportPlaintext organisationSLIME (a Emacs mode for Common Lisp development)magit,org-modeIntegration with LaTeXAlso its generally well-integrated documentation; also a feeling of featurefulness or maximalisminertia and muscle memoryLisp-nessisearch , org-mode , outline-modeFree softwareAucTeXGeneral-purpose toolit lost me immediatelyWanderlust email clientClojure support by CIDER extensionKeyboard macrosvimBrain wiring has been molded around Emacs use after many years...HackableRmailmagit, org modeGot used to the keybindingsavail on freebsdcustomisability, professionalism, configurability, adaptability, coverabilityProgrammable, magit, evil (vim)Inertia and muscle memoryBecause it's freeevil,spacemacsOperating SystemORGI can use the same text editor for (almost) all text related things on all platforms.asdfRobustnessI can build better workflows in Emacs than with other toolsIDE featuresSLIME/SLY for Common LispThe railwaycat Mac port: if this disappeared I'd stop.org-tree-to-indirect-bufferBest dang VHDL editor out thereavy, evil, iedit, orgbest editor everI'm too deep into the shortcutsDoomEmacsBest clojure editorBased on LispMy fingers know the key-bindings I needRuns everywherehabitual key bindingorg-mode, evil, spacemacsInteractive programming with Lisp (slime, geiser, and similar)I know the key bindingsOrg, longevityJust makes senseKeyboard drivenIt's the best text manipulation engineMulti-platform; Free SoftwareReliable interface across domainsMuscle memory, lispCan't find anything better at the momentAccessibility for blind users with Emacspeak.Functionality I can't get elsewhereit will still exist in 20 yearsNotmuchorg-mode, magitmagit, org-mode, evil-modeShell integration: rcsDoom Emacs by HlissnerProgrammed in LispPromise of being able to adapt it to my needsGuix code conventions basically demand itIt's easy to build any feature I make up.programmabilitySame editor for everything & everywhere.Org, magit, DoomHabitual long useit's lightGnus, jabber.el, TRAMPOrg-mode, Evil-modeOver VSCode: terminal compatibility, user extensibility. Over Vim: Available packages.keybindIDE for Common Lispcross-platform consistencyComplete and total control over _every_ aspect of my toolingEViL mode is what ultimately made me an Emacs main. I have a soft spot for Vi motions.It's lightweightThe eventuality to be have a single software to deal with most of my informatic needsGPL LicenseInertia: have been using Emacs since the late 1980sorg-mode, cool people, that i get to learn about computing and modify my uxgnus, org-modedocumentationI'm used to itC IDEconfigurationconsistent interfaceOpen source/free (not exclusively because of GNU)Use to itEmacs broke my brain, i can't use other key bindings nowportable, remote editing, orgmodeSLIME and org-modeemacs-lsp maintainerBuilt-in reliable documentationEmacs-Lisptoo manyFamiliarity with keybindingsledger-modeMuscle Memoryshell, compile, dabbrevOS indipendentFocus on keyboard controlsIt stays when closed competition self-destructs or ruines uxevil/org/magit/trampEvil-modeFreedom, I can invest in itAvailable on most platforms.Xah Fly Keysorg-mode magitorg, magit, doomLongevity, absense of malware and spyware featuresconsistency; what used to work still worksTty experienceLisp is coolcopyleft licenseFirst class terminal supportCohesivenessMagit, Evildoomemacsgod tier font renderingeglotThe ability to find and fix bugseverythingEasy editing macrosSame editor, all platformsIntrospectability and hackabilityalways there, familiarI use it as my main work IDEReadline shortcutsSimplyComfortRepl, lisptoo old to learn something newMagit, org-modeAnd because it's way too fucking cool not toEverything is text and accessible with keyboardI'm founder of lisp.com.br (Brazil)org-mode, magit, projectileIt's free/libre softwareportability, SLIMEorg-mode, programminglispy.el and org-modemacaulay2Org, magit, LSPKeybinding muscle memoryMusicmagit and exwmFreekeybindingusing lisp as extension languageORG modeAgdafock fsffamiliarityparedit, cider, magitfree softwareCross-platformlisp (repl, sexp, ...)design philosophyIt's one of the few tools that I feel like I have ownership oforgmode, magit, slimeexwm, magit, lockstepI no longer use Emacs. I switched to Vimgreat support for lispy languagesBeing truly FOSS with no compromiseit gets installed, but I don't use itMalleable softwareOrg mode, magit, elisp in generalPerformance, reliability, knowing it will always be aroundfinger muscles are conditioned to emacs keybindingsslynkQWANAllOrgModeEthos of freedom25 years of muscle memoryHistory/LegacyMagit and org-modeIt is just what I am used toInteractive and introspective Lisp environmentDeveloped by RMS!org-mode, gnusFinger Memorymagit, CIDERShortcutsLisp, great OFFLINE documentation, being self-discoverableMuscle memory, no mouse requirementA strong foundation of openness! (ie. no proprietary plugins like VS Code)Great user interfaceNone, really. I don't use it much.Hackability and transparency (open hood)Private / no telemetrynon-modal keybindingsCommon Lisp IDEs, Org-modeNerdityDOOM emacsFamiliarity with key combinations and featuresORG drew me back (after 30 years)Introspection, Lisp machineLisp , Terminal UIESSIt's based on lispScriptabilityFOSSLSP supportyesClojure developmentOpen-source. Old habit.there's no suitable replacement in the universe. emacs is THE superior editor/ide/operating-system/whatever.self explanatory (c-h ...), consistent UXlethargylsp-mode, ivy, swiperdecades of muscle memory :)the vision of a unified scriptable environment that i can live inKeybindsHas always been available on all platforms; will always been available on all platforms.I'm used to it and it works wellthis is a loaded questionorg-babel for reproducible researchorg-mode, magit, coding supportIt's a mainstream editor that's not Electron-based ;)Magit org-modeorg-mode, org-roamorg roamBeing used to it so much I can't really use anything else anymoeeELispEmacs LISP!!!!!!!!AvailabilityC-a, C-e, M-b, M-fmaggitorg mode, arista extension, e.g. bug-mode, etc., my own personal extensionsStability. Any effort I put in to emacs pays dividend foreverKeyboard Driven FTW!AestheticSimplicitySelf-documenting (introspectionllisp,free software, magitBeing mouse-freeI love that Emacs is Free and open source - those are two major reasons why I use, but I cannot say that its "affiliation" with FSF is a reason that keeps me using it.CustomisabilityHigh efficiency ceilingSelf documenting, Offline support, IntrospectibilityLSP & Magitfeels more solid than VS Code or other competitors, somehow I feel that I know where my keyboard focus is on Emacs and I'm never sure with those IDEsi use it for everythingorg mode, org-roamIt's fun!CIDER; magitreliability & elispOrg-Mode!Org Mode!Evil and org-modeA benevolent kind of lock-inEmacspeakorg, mu4ethe meow-edit packageorg-mode/evilFree SoftwareSlime/SlyThey can't take it away from me.That it's free softwareThings no other editor hasKeybindingsAddictionInput methodsEvil modeorg-mode, evil mode (Doom :-))ORG-mode'(elisp lisp)tramp!magit, orgOrg, embedded Latex, embedded codespacemacsAuctexI can use it for the next 25 years and still have a better editor than anything newerOrg, lispIt's free softwareReliableDeveloping eMacsDoom/evilThe implementation, integration, and refinement of methods or tools from outside of emacs into the ecosystem. Also image rendering, without image support I couldn’t “live” in emacs.Stability of internals, carefulness in evolving them (mostly)Uniform and powerful interface to text and edit/debug cyclesIt is the most logical and reasonable way to use a computermagit, evil, org-modeNot using the arrow keysConfigurabilityorg mode, magitorg-mode, many programming languagesPrivacy respectinglexical binding and other cleanup of technical debtGUITime invested in the configurationTradition
How were you introduced to Emacs? StringInternetUniversity/CollegeColleagueFriendWorkParentRedditFatherMagazineDaddon't rememberBookCuriosityRequired for workFSForg-modeMy dadDon't rememberbookcan't remember4chan /g/LinuxfamilyRMSFamilyI don't rememberHacker News4chanWas on my amigait's everywherer in the free software worldMagazine articlelisp booksn/aThe Social NetworkA book on LinuxAlways known about it since I was first introduced to Linux 20 years agoErlang Mode /tool for Emacs `https://www.erlang.org/doc/apps/tools/erlang_mode_chapter.html`ORG modeGNU philosophyIt would come up from time to time in computer journals and magazines duiring the 1980s and 1990s.First workplace was pair-programming heavy and the editor was Emacs, so I was forced to learn. It was great.https://m.youtube.com/watch?v=JWD1Fpdd4PcSpacemacs4chan /emg/Didn't stick in my mind as this is emacs at uni. So colleague actually made me understand laterNeeded to use EmacspeakInstalled as part of a linux distroI don't remember, so long ago.YoutubeIt was bundled in Mark Williams CMicroEmacs on AmigaOSThe Clojure communityBy System Craftersco-workerByte magazine commentI did some research and choose to learn EmacsI use vimfather used iti don't rememberIt was installed on my Mandrake distributionsearched for an IDE for ClojureHad better out of the box experience for python than VIMmentions on the blogs of the 2nd generation of geniusesJon PostelCannot rememberKnew about Emacs for many yearsPractical Common Lispbook(I was learning PHP, and text book recommended emacs)It was recommended in a programming manualread about from beepb00p.xyzHPUX Users Group in mid-80'sOrg-mode plug-in in neovimAaron bieber's talkSteve yeggeLUG meetingsBook: Practical Common LispYouTube algorithmgnu/linux package90s SuSE LinuxClojure For the Brave and Truebook: the pragmatic programmer_Running Linux_ by Matt Welsch. I saw the intro to vi and I said no.Linux manual by Michael Koflerevery Vimer know his enemyStallman talkRecommended as Common Lisp "IDE"I thought for coding you had to chose either vim or emacs and I chose randomly.Read somewhere about Spacemacs, then got hold of Doom when it started as one-man project, then moved to my own config.Initially University, but later on reintroduced with org-mode; now still using mainly org-modeAlways knew about it but never tried it because Vim was sufficientSteve Yegge's postsAFAIK, Protesilaos Stavrou's Emacs videosThe Cuckoo's Egg by Clifford StollCliff Stoll's "The Cuckoo's Egg"curiocityXah Leemy fatherI've known about emacs since the 2000's and tried it then, it just never stuckIt was the development environment on HPPAGot a job in clojure and CTO showed me the power of the REPL integration and I was forever hookeddad's been using it for 4 decadesworkwhen i discovered Linux in the 90sSlackware packageWhen learning clojureI was looking for an editor that could hide markup like Typora and then I've found Org-mode and EmacsHandmade HeroBeing a nerdA "geeks" spanish podcastI was using mEMACS which is coming on Amiga 500's Workbench disk as a default text editor.Sacha Chua's blog on emacsWas searching for a libre vs code alternativeColleagues at workFriend was maintaining his exomind in Emacs.Linux distro had itcame included with a GNU/Linux distributionGithubcame pre-installed with Slackware and was heavily advertised by the GNU projecta book "Clojure for the Brave and True"My brotherGNU Software for MS-Windows and MS-DOS CDMentoranother C DevAt workemacs-china.orgPassion for LisporgmodeI do not recall.Evil Mode: Or, How I Learned to Stop Worrying and Love EmacsRMS & GNUit was the first editor I stumbled on after installing redhat 8Everyone at work uses itI read a book where Emacs was mentioned.was pro vim. wanted to know who were right. now I knowI hated vi, and Emavs was the only other editor on the Unix system at collegewas already using many years agoBook "Pragmatic programmer"Started in a unix shop, emacs was basically the default editorThrough the Desktop menu (Red Hat 5.2)Recommended by a friend because of org-modeCame SUN OS workstations where I workedI have always been fascinated by learning a lisp and clojure was huge at the time and I could not get vim and clojure to work well...so I switched.observationBook "Linux" by KnoflermasochistsI forgotNeeded an interface to RA book by Dave Tyler with a stupid title but great content "Sams Teach Yourself Unix in 24 Hours"Youtubersconference intro to org-modeIt's basically required for agdaProbably from some Shareware/FOSS discxmpp emacs roomClojure booksconversations in a college terminal ward (not an official program)Started using more LispI wanted to change something in Qt Creator and I couldn't. I heard in Emacs I would be able to.GNU/Linux distribution purchased on shelfSaw ppl using emacs - made me fall in love observing itBy looking for good Haskell editorSaw someone use org-modeA Coursera course I was taking was taught using Emacs - Programming Languages, Part Ait was installed with my first slackware installfree software movementLearning ClojureIn the Beginning Was the Command Line (N. Stepheson) + AUCTeXMicroemacs manual in the back of my Amiga manual.was part of the default install on the first GNU/Linux system I tried.I wanted to use the SLIME package.Went searching for a text editor with the features I wanted that I expected to be around long termDad used vim, found org mode to be superior for computer only notesWorking through Practical Common Lisp. SLIME was the recommended development environment.Selfdistro manualused it back in 1994 on SolarisRecommended by college professorFirst jobDoom Emacs; found that on youtubeYouTubeLinux ISOIt was mentioned in magazines like Dr. Dobb's and it came with my first (GNU/)Linux CD.After installing Linux Mandriva, in 2006, Emacs was there.YouTube talk on ThoughtBot channelLocal pusherI searched for the text editor that was most customizable and that would best pay off in the long term.Development support for clojurebsd communityvim and emacs as most used text editors on linuxdebiana book, suggesting emacsvim and nano, vim seemed intimitating, nano like a toyorg-roam was the reason to try EmacsJust wanted to learn something different and freeFound on Slackware discsFound spacemacsdecide between vim and emacs.I was learning from Info browser and stumbled upon Emacs, decided to try it.I discovered it on the internetChanceClojure communityFirst at university, then a colleague piqued my interest by showing me SpacemacsI needed to implement GTD methodIt was on the PDP machine and I was curiousUnsure, I suppose I read about it somewhereNeal Stephenson's essay In The Beginning Was The Command LineSlackware Book 1998Talked to the FSF table at LinuxFest NorthwestSymbolics Lisp MachineRecommended for Common Lisp (ilisp package)Found it on SunOS and thought it looked easier than Vim.From trying Linux for the first timeI think my dad uses it?because of microemacsThrough the Lisp programming languagemedia appearanceLisp machinesRecommended by Practical Common LispHad been using microEMACS bundled on Amiga alreadyThrough using vim and wandering if vim-keybindings could be used in EmacsBoyfriendBack in the 90' Linux distros came with a handbook. Mine also included an Emacs ref.It was one of the two serious editors available on the first Linux distro I tried (RedHat 4.2). I liked it more than VI for some reason.functional programming editorCan't rememberGNUPretty sure it was videos related to Linux when I first stumbled upon Emacsan android app called OrgzlyFamily memberi do not rememberRecommended by my Dad (thanks Dad, love you <3)don't remember but would have been because of information about RMSToo long ago, I don't remember.redhat manualBooksavailable editor in RHEL 5, workbook on LinuxEmacs said Hi, I said bye."Evil Mode: Or, How I Learned to Stop Worrying and Love Emacs" by Aaron Bieber, video is on YTOnly way to program sanely in Common LispI've been trying it out off-n-on for 20 years, since my first linux install.Casey MuratoriYouTube videosUsed it on NeXTStep.The movie Social NetworkBecauseI wanted to use Agda which, at the time, only had an interactive mode for Emacs.Book: Teach Yourself Unix in 7 DaysThe social network quote by Zuck: "So it's definitely necessary to break out Emacs and modify that Perl script."by watching Handmade HeroForced to use it for a very esoteric job and everything else just sucks more (unfortunately)First exposure to it was some time in the late 80s, some kid had all his ideas stored in text files on a PC running Emacs and was showing it off.Long standing reputation, fsf.Magazine article about Org in Linux JournalIt was used by my research teamemacsrocks on youtubelinux.org.ru forummy father :)Don't recalltextbook about unixfrustration with vim ecosystem around lsp, etc.Linux InstallationSearching a package managerno lisp machine availableAaron Beiber's video on EmacsRecommended as a Clojure IDE (CIDER)increasing awareness of org mode and a match between it and my requirementsMicroEmacs was the main Editor for M2 Modulator2. At uni it became EmacsPart of HPPA development systemIt was the default editor for VHDL and Verilog at my first companyWatching tutorial, noticed it was possible to make these OLD terminal editor looks modern yet powerful. SO I ended up choosing Emacs over Vim cause I didn't like Vim modal editingSome guy on the internet said it was the best LaTeX editorWhen i learn linux,i read the book name "Vi and Gun Emacs"looked at it from vim for as long as I can rememberlooking for a batteries-included vim, found spacemacs insteadEric S. Raymond’s case study on editors in “The Art of UNIX Programming”Started using SlimeNobody introduced but saw several professors using emacs in my universityUbuntu software manager recommendationOrg Modesaw it in the handmade hero YouTube seriesI always knew about it but this vid won me over https://youtu.be/JWD1Fpdd4PcI wanted to program in Common Lisp, and the community was there in Emacs and SlimeI didn'tCanct recallHNnothing else worked for me, internet's only remaining suggestion was emacsHigh SchoolMy professor said I should use emacs so I used vim instead and then came back to emacs years laterfsfalways meant to devote the time to itI wanted to learn lispRecommended by a mentorDigit magazine in LibraryMicroemacs on PCproductivity pornhacklabI knew about the Vim vs Emacs rivalry, and when a friend picked up Vim I decided to pick up Emacs to spite him.Back in the late 80svia the amiga memacsJob mentorDistrotubeSICPCoursera course: Programming LanguagesPrinted magazine articleMacOS available editorsorg-mode videodefault editor on redhat 5.2me and a friend decided to partake in editor wars, he went vim i went emacsjob requirementLex Friedman podcastClojure for the brave and trueWas in the list of available editorsIndustry training classPhilip GreenspanOriginally a long time ago by my high school physics teacher who went on a rant one day lambasting Microsoft Word. It made quite the impression!Professora paper magazine, back in the day, called "Solo Programadores" (only programmers)Saw that many serious Debian Maintainers used GnusUncleWanted to learn lisp and have a an editor that supported it wellSLIME, as I learned CL and Emacs at the same timePragmatic programmer bookDistroTubepart of GNU/Linux and better than Vimfirst time Linux user looking for a text editorgnu/fsfStallmanForced myself to learn at an internshipvia ESS and writing R codesA Linux for beginners book, don't remember whichhttps://www.youtube.com/watch?v=JWD1Fpdd4Pcparentself-studyhelp command on Super Dimensional Fortress pubnixRichard StallmannBook; Clojure for the Brave and TrueJust decided to try VIM’s main competitor.emacsI was 19 years old. Vim seemed very intriguing, advanced text editing by the fingertips. I was playing Team Fortress 2 much at the time, did a lot of keybind customization which was inspired by Woolen's config on YouTube. I found Xah Lee by DuckDuckGo image browsing. It was a link to his shit-on on the HHKB, fantastic article. I don't remember how i found Xah Fly Keys.Recommended by a bookfatherpodcastCuriosity when migrating to GNU/LinuxMOTDDon't remember - surely no colleague and the internet was very small back thendad <3MacOSRecommended by a colleague/friend and the internetsummer program in high schoolSystem CraftersProfesor told me about the extensibility of emacscame with the distroFound used Emacs bookesr's Jargon File 3.0.0 in about 1995. Took me a while to get religion :)JobAmiga had microemacsSaw that senior Debian Developers used Gnus for e-mailRecommended by a professorPrinted SuSE manualIn those days you had vi and emacs on a unix box: pick oneexplored soft in repoit was installed by defaultWork. Amazon customer service ran on emacs, and we were all trained to use it.Fred Fish's collection of Amiga ports of GNU softwareMultiple people in a short timeframe mentioned they used Emacs, and it got me intrigued to try it outBook Running Linux 2nd editionFree software cultureCarsten Dominik talk about org-modeI was forced by my manager to learn an emacs compatible clone called epsilonLinux distro docsThe colleague wrote Multics emacsA tech conference had one of them wizardsEmacs came with LinuxSelf motivated curiosityJonathan Blow game devonXkcd Butterfly + Vim holy war memesDon't remember, srly.Used it years agoThe Debian documentation4chan's /g/ boardLooked for most extensible editorI found it on a Pr1me ComputerRecommended for haskell development (haskell-mode)Was told to choose Vi or emacs and learn by first managerdadI had the need to develop snippets for Emacs.DTThe smartest guy in the company used it, so why shouldn't I?/g/Unix related booksYouTube video: Watch later Add to queue Evil Mode: Or, How I Learned to Stop Worrying and Love EmacsI was looking for an editor on GNU/ LinuxJob requirement (common lisp)clojure development setupFree Softwarehigh school cs teacherhigh schoolIt came with Slackware.curiosityStarted it out of curiosityclojure communityBook "Clojure for the Brave and True"USENETSteve yegge blogOrg, as a (better) notebook formatI did my own researchZmacsCD-ROM attached to a magazinea hacker I looked up to was using itWas on a system without internet and needed to do something. Emacs worked and I stuck with it.Some part of the internet, and almost simultaneously by a professor of mine. Common Lisp and SLIME originally brought me to Emacs.I was IT guy to a pure unix shopemacs chinausenetlinux user grouppersonal curiosity, sysops discouraged use of Emacs because in 1992 it was considered a memory hogsaw an emacs praise lecture at a conferenceSelf exploration while working with unix in 1990"Some part of the internet" counts but also time as a PhD student about 20 years ago."Running Linux" 1st edShocases on YT first, than seein it in action in a conferenceUniversityGoogleStandard as a CLisp dev.I wanted to learn Common Lisp, and Emacs is almost the only game in town as far as IDEs go.meClojure meetupsPart of Common Lisp engagingintroductory linux booksEmacs has best support for lisp. I could not figure out how to do lisp in vim.probably xkcdlearn unix in 24 hours bookI was learning Common LispAaron Bieber’s thoughtbot talkSLIME & org-modeSystem Crafters on YouTubeI was fed up with Vim and every other editor/IDE that was out there.MemesDistroTube on YouTubeDon't recall but O'Reilly's book "Learning GNU Emacs" was an essential part of me learning and sticking with Emacs.I were looking for a python IDE, and spacemacs were listed by quite a few people.A friend of mine recommended Vim, so I downloaded Emacs (this is not a joke!)It came with the distro
Have you got any feedback on the Emacs/GNU ELPA contribution process?

This regards the overall process: obtaining FSF assignment, path submission and review by email, etc.

String
NonoNo.N/AYesn/aNANO-yesYes.No paperwork. I refused to do that.The email-based workflow is discouraging at best, and it is not clear at all on how to submit patches and contribute. Many patches and bugs gets dissolved by having no central page of listing all patches (on how GitHub has an issue, PR list), and searching and referencing prior patches, discussions are almost impossible without already knowing beforehand. The bug tracker debbugs is needlessly slow and complex, without any web UI that I can simply reference. It provides little to no aid on helping how to create a new bug (which, as I recently found out, is screened manually at first; I thought I failed to open a new bug report until after a day when suddenly my bug report appeared). The FSF assignment process is not as streamlined as I'd like, as it requires for myself to email the FSF to start the process; I'd rather be able to start the process as soon as I decide I want to assign my copyrights, (for e.g. by downloading a PDF that I can write my information, sign on it, and submit it via a web form / email, and then FSF can contact me for confirmation).The contribution process is fine by me. I like contributing via email workflows.Mailing lists can be a strong barrier to entry.I wish the process was more GitHub-centric. Not really interested in ELPA.Hard to trust GNU/FSFFSF assignment took a long time which is frustrating. I dont mind email review though debuggs giving a different email for each patch feels a little weird. Maybe using something like Guix's issue tracker could be an improvementnopeFSF assignment.I once wrote a Babel language integration--m4--for org-mode. When I was asked to screw around with paperwork for something I'd written and tested for fun, I noped out.yes, patch has been reviewed and mergedI've never contributed. I've only made small, personal packages.E-mail, as a process, is /incredibly/ open-ended and not very aidful for the disabled as it's not clear what is supposed to happen or what the guardrails are. Treating users more friendly and as if it's their first time and, so, explaining everything friendly, could also help; not everyone has the spoons to RTFM to the degree of perfection: it's a /lot/ of text with no quickly dicernable outline.I have yet to find the FSF assignment papers, do you have to ask for them on the mailing list? I would like a form with a blanket assignment of future contributions to *all* projects whose copyright the FSF already has, not sure if such a form exists ATM.None.FSF assignment can be tricky depending on employer. I would like to contribute to core emacs via FSF, but it’s guaranteed to take longer and require more hoops.The assignment part is annoying and detrimental to getting new contributors.Use Github also replace elisp with a modern language before neovim takes over.Not really.no. i don't see a point of the whole fsf assignment.It's 2022, sending patches by email is just embarrassing.No really. May their beards be long and their nails trimmed. I know it's true for me.The process has changed and matured over time, and as I only occasionally commit anything, the process always seems to have changed since the last time.... It has gotten simpler thoughGreat, even before you sign the paperwork. Obtaining the paperwork is also super easy.Just few lines patches. Process was quite easy (git clone, git build email patch, send patch to mailing list)I would like to contribute somehow, but it does seem slightly daunting to submit patches by email. Maybe if I tried it, it wouldn't be as bad as I think though.Mailing lists are a pain because I use them so rarely for anything else. Paperwork is annoying.obtaining FSF assignment guide is hard to follow (for example I don't really understand if I can sign it while remaining anonymous)I use vimDon't knowif the contribution process were easier, I would contribute!I hate emailNit aure what happens thereI think it is fine. Perhaps it could be a bit faster, if the FSF had more resources available for it.Yes. I've observed stubbornness towards new would-be contributors for daring to highlight their familiarity with git-forge approaches compared to a mailing list.the questions in this survey are scaring me enough to never try it, but GNU in general seems hard to talk to.My university's lawyers are dragging their heels on FSF assignment, sadly.Have not tried to contributeI don't agree with the FSFs focus. Furthermore, he FSF seems to serve as a vehicle to rms's ego.Paperwork: You need to come up with a process that doesn't involve legal paperwork and real names. In 2022, plenty of talented developers don't want to or don't feel comfortable providing names, don't want to deal with mailing things, and don't see why they should when other bigger projects don't require it. I know there's a fear of nebulous bad actors retroactively pulling all their contributions, but show me a time that has happened. Find a way that's electronic and doesn't involve identity verification, tie it to a gpg sig or something. Mailing list: Using email is annoying but not unusual; other projects move this way. Emacs-devel is a weird place and shows really weird practices. Core devs push directly to master. Lots of ideological argument untethered to code under review. I don't have a sense of what the code review process is supposed to look like when it's running well. Does a patchset have to be acked by core maintainers? By maintainers of subsystems? Who are they? Is it just Eli Zaretskii? Are there others? Are they distracted by flaming each other about how to phrase manual pages today? What patchset was accepted, anyway? How do you know? It's not in git metadata. People don't push versions of patchsets, just post fixup snippets. Should patchsets be bisectable? There's expectation of style, but there's no checkpatch or formatting tools? The mailing list seems like 5 people who've known each other for 30 years posting little changes they like and sniping back and forth on well-worn paths that they've been doing forever. There needs to be - Defined, documented, and adhered-to expectations for a patch review flow including by core maintainers - no pushing to master! - Tooling for things like style. Patch doesn't pass stylecheck? Fix it. Single email, no markup of every line in a patch. - tipbot that builds patches To sum up, please figure out a workflow for people to work pseudonymously. Please define and adhere to a more structured workflow for patch review. Please invest in automated tooling to check common stylistic problems in elisp and c.It was a small fix, but I was a bit disappointed that it was committed to emacs with zero credit. The committer did later apologize for it though. Guess I'll have to fix something else too :)It's been years since I looked into it; should give ELPA another try. I am more active with MELPA so far.The info is not very straightforward to find (maybe there should be a command to the contributors info file), but otherwise, FSF assignment and submitting packages is very straightforward. Also, the developers (mailing list) are extremely 'helpful'.i recently have tried, once, to send a bug report on emacs, explaining that american-centric dates were a problem and was basically shot down. see bug #53396, pretty discouraging.I am anxious to contribute. Get employer paperwork was impossible at IBM. May succeed at my new employer.It's onerouscan't stand it... the dogma... the friction...I'm regularly following emacs-devel. For me it seems that some people (maintainers, etc.) directly push changes to the Git repo. For me this is an uncommon approach, I would expect that every change is reviewed first before it is pushed.Nice to be surrounded by committed people who know exactly how to help.My positive experience is from too long ago as to be of any current relevance.archaic processes, toxic community, very unwelcomingI haven't tried to contribute therefore I cannot give an update/feedbackI need to understand elisp better before IThe mailing list format is outdated and should be changed.It is time to take this part of the process extremely seriously. The web should literally be the version control system / central repository of software. I am tired of having to go back and forth between various out of sync and incompatible formats or programs. I am so fatigued that I basically don't bother using the computer for much and it is why my answers on the last page were mostly "no" - because I just don't have any reason to play along. I have no friends in reality who do these things and I have no income.. I care more than most but something needs to change on the societaly level so that people like me will be willing to be a part of the free software world. I need to be allowed to keep basic dignity and have a basic social life but this country is run through facebook... I think working on free software is valuable and I want an income doing it. I shouldn't have to be some elite powerhouse programmer to be eligible, there's plenty of chickenshit devs working on yet-another-nonsense-application getting paid ridiculous sums. I won't do that. So where does that leave me?I got it started; then the process just came to a halt.The mailing list community is very helpfulI have no assignment and it is hard to arrange with my employerI had good answers to my issue on Korean input in Emacs.I'm really not a fan of the review by email process, or by the apparent culture on emacs-devel.Not really as they work pretty good for me.I would never consider giving Stallman authority over anything I write.Remove Stallman once and for all. Don't allow him onto any mailing lists. Don't allow him to have commit access. Stop protecting him from consequences.Haven't read about it.I haven't tried to research the entry points, I suspect that they are documented well, as other topics on official Emacs website seemed to be documented well.I would certainly contribute, at least documentation, if I could do so with Git.It is hard to handle 100 email per day when subscribed emacs-develn. a.Some members of the community on GNUs end are so off-putting I steer clear of it entirely.Ditch the mailing lists. Use a proper tracking system.Yes, and it was consistently helpful (thanks Stefan Monnier)!Look frightening, intimidating. I'm not sure to understand why my company should have something to say about my hobbiesOverall, the experience is (usually) pretty painless. I think it would be helpful to have more documentation-by-example though: that is, pick a recommended way to generate patches and have the manual say, effectively, "Just type these commands." For example, it could recommend working on a Git branch and then using `git format-patch` and/or `git send-email`. (Of course, people who want to do things another way still can, and the rest of the manual should help guide them too, but a simple recommendation would be nice.) The same principle could apply elsewhere too; maybe for ELPA submissions?It was more than fifteen years ago when I was living in bangkok and everything went smoothly, even the post office...Signing copyright is fairly simple, and Emacs developers are quite friendly on the mailing lists.Too time/effort consuming on *each* stage of the contribution process. The same time, direct commits don't get (proper) reviews at all.Haven't had cause to contribute yet.Get an automated copyright assignment instead of emailing pdf formsI heard it takes foreverI think it does a great job promoting the health of the Emacs ecosystem by fostering a wide and diverse range of alternative package sourcesI would have no problem obtaining the FSF copyright assignment. Being free software is one of the reasons Emacs is great and why it continues to thrive.Go to github or gitlab. Mailing lists and sending patches is horrible.prefer using GitHubI guess I can appreciate the care that goes into making sure the FSF can represent you if some company breaches your IP, but I can't really be bothered going through the effort of doing the whole copyright assignment thing if I never really see a reason to edit the packages I have in the first placeI have only reported a bug and tried the fix provided, all was quick and devs very kind and helpful.FSF assignment was fairly painless, but had a patch sitting for years without being merged even though it was accepted and bumped several times, so that was a bit annoying (though perfectly understandable considering the workload of the maintainers and the low importance of the patch)yes - obtaining FSF assignment, review by emailI'm against the burden of asigning of Copyrights, specially if I have to get approval from the company where I work.mailing the signed paper can be expensiveMostly that I needed to strip tests on one of my contributions to be considered a TINYCHANGE, and direction to signobtaining FSF assignment is a blocker for me, I wish it didn't exist.I would if it weren't for the FSF'd dubious leadership.Not interested: lack of time, unclear process. Platforms like Github make contributions easy: fork, push a change, open a pull request. I only have this much free time, and this survey is taking up most of my today's allowance. I don't mind waiving / assigning copyright - but you need to make it as easy as ticking a checkbox. Assume that every single step in a process will scare away 90% of potential contributors.I had a patch to shr, submitted and accepted, however I let the paperwork barrier prevent me from signing over the copyright. The barrier was printing out the paper and mailing it. It felt archaic and at the time one more thing that was piled on my todo list that was already overwhelming me.It seems complicated but I've never attempted it. I do wonder if Emacs would be better off opening up the doors to contributions past the whole ideological battle it's (rightfully) trying to lead.As mentioned in a previous comment, I work for a multi-national large corporation for almost 20 years and have not been able to find the right person/people to present the paperwork to. When I've asked, most people don't even know what I'm talking about. As a result, I tend to avoid contributions where FSF copyright assignment is needed.I find the FSF assignment process disastrous. I have used Emacs every day for 30 years. Despite my love of Emacs I cannot see me ever signing up or "submitting papers". I read the emailing list (and never reply). The recent "hatred" for other platforms beyond Linux is terrible. And I've daily-driven Linux since 1995.I don't understand well what the question is trying to capture, but I guess the answer is "yes"?As a university student not in the US, it's kind of confusing with the supposed claim that my university could have on my contributions and whether that would apply to me, which has prevented me from signing the assignment.I won't do FSF assignmentThe only contribution I ever made was a simple pull request on GitHub, so I'm not familiar with any of the mentioned steps.Will not sign the paperworkI never got the assignment process finished nor my application approved.It was pretty straightforward for me honestly. I do wish that FSF assignment wasn't necessary though, it's a hassle to get approval for it through work, which is why I currently can't contribute since I'm still sorting that out.Good feedback on a few Org patchesNot really. I tried to sign FSF papers some time ago, and may have done so successfully, but ran into a problem contributing further because I worked for a university that required me to sign an intellectual property agreement.Screw lawyers and the legal crap they force onto people to write code. Also, pay people for their work and give them those donations that are being stolen from them. I will NEVER contribute to a criminal organization like FSF.Tried to obtain FSF assignment but I didn't get a response from FSF for a long time, then asking for something different. After that I lost my motivation and ultimately didn't contribute more.I don't think the assignment still makes sense.I want the ability to subscribe to just one email thread, not the entire mailing list to submit one single patch. I’m constantly deleting hundreds of emails on the off chance I might need to participate again some day. Or just have a forum-like web front end for it, like bugzilla.FSF paperwork means vast swaths of code don't get mergedFSF assignment is basically impossible.Obtaining FSF assignment is difficult for a small portion of us who work at bigcorps.I had one package submitted in org/contrib. I maintained a version on my personal GitHub as well, and got contributions there. The versions went out of sync, and FSF copyright turned into a bit of a hassle because I had accepted pull requests.I will not sign the FSF assignment. It goes against the spirit of freedom, open source, and equality. Another entity should not own my work. As the kernel has shown, there is no legal reason for the assignment. I would be happy to contribute if emacs was on github/gitlab with a standard workflow based on PRs like the vast majority of the community and if the assignment was abolished.asdfThis sounds like you are fishing for complaints. I think, it's good to have several archives with different requirements & review processes.They banned meA decade or so ago I tried to sign some papers for copyright assignment. It was a pain in the backside. Have not tried since, and don't intend to, so as long as copyright assignment is a requirement, I'll spend my contributions elsewhere.Obtaining FSF assignment feels like an unreasonably large barrier. It's taking me over a year of back and forth with my employer and the FSF to try to get it done.Again, I do not want to further involve myself with GNU or the FSF due to toxic community elements such as Stallman.It needs a well written, easy to follow, guide that I can point to people, or legal department in my company to understand what is required of everybody, at each step of the process.Forcing the use of email seems a bit antiquated to me personallyReply on the email listI once sent a patch to emacs mailing list but there was so much bureaucracy I was disencouraged and signed the paper giving fsf the rights so they would make any further changes necessary.it's currently blocked by my employer not signing the documents.I am not sure. The only case I would do anything related to Emacs/GNU is submitting Emacs bugs.No ideaIt's too laborious.Absolutely no interest in doing paperwork and sending actual mail.There should be video walkthroughs of how it can be done.No list of good first issues. I tried the recommended way of finding issues and it was hard to navigatePlease move the whole process to Github and automate FSP copyright assignment with a bot on Github. Also, please remove RMS and Eli as mods. Both are incompetent and lack ambitions and visions.My employer would not accept FSF assignment agreement.NA - I only did a logo design oncecode review and ci based on gitea would be a welcome enhancement over savannahI don't even bother looking into this. If it was just a normal process of submitting a PR on github I might contribute but anything beyond that is too much bother.I think the FSF papers should be readily available to download from a public accessible website instead of being sent offlist when asked.For new package authors I suspect it’s somewhat daunting to launch an email straight to the Elpa dev list. Perhaps a webpage with a checklist form that generates a message would lower the barrier.Unsurprisingly, a lot of hoops to jump through, as with many older and/or FSF-overseen projects. It's not that I want everyone to move to GitHub and buy into a closed ecosystem, but things could be made much more streamlined.It's was quite slow, but overall quite clear what to do.I think the contribution process is fine the way it is. If it were easier it would encourage low quality fly-by contributions lacking follow through. In fact, in my opinion, the bar should be higher, and in particular code contributions should be rejected until they have adequate documentation. It would be nice if core developers had more time for mentoring, to help novice contributors improve their skills, but where-oh-where is more time to come from?Not yet proficient enough to go into that just yet, but this is the first I'm hearing about FSF faffIt's annoyingIt all seems fine to me but I don't mind the old school thingYes, I have a package in ELPA.I think a switch away from mailing list to something like GitHub would lower barrier of entry significally.I had submitted a patch but stumbled on completing the paperwork and gave upIt is very good, single place for all messages, well-curated posts.Quite straightforward (compared to MELPA)What’s FSF?The form for copyright assignment could be linked saliently on the webpage. I had an issue where the person I contacted forgot to attach the form which led to much confusion. More importantly, I think the biggest problem is that it's unclear how much you need to do to get the assignment. That confusion makes it sound scarier than it actually is. So, outline the entire process and make it easy to find.I would really rather prefer a DCO instead of copyright assignment. FSF is probably the only organization I'd trust to not abuse an assignment, but I still don't like it.I tried to sign the paperwork, but the process took a reasonably long turnaround; my manager at work at the time also had to be involved to approve some things, and after a lot of effort, I got up to the point where the paperwork was emailed to me. Unfortunately the actual documents ended up sitting in my spam folder for a long time, before I realised they were there. By that time my motivation had disappeared into the ether and it never was completed. As for the actual submission process, I would not find the motivation to submit anything anymore. Even if I do have useful patches for emacs, the workflow of contributing over email is a snowflake; i wouldn't have to do that anywhere else, and if i contribute to emacs once every few months, i'd have to figure it out from scratch, and just thinking about it makes me not want to bother. It is easier to keep my patches local and have nix build emacs with any patches I need, rather than even begin to think about contributing them upstreamThe GNU Emacs maintainers are incredible! Posting to emacs-devel can be intimidating if the topic may be controversial.Having recently gone through the FAF paperwork, my employer was very concerned that the release was overly broad and could not carve out exceptions for anything made with their hardware/software resources.I mainly submit issues, rarly doc patches, feedback are helpful emailsPeople skills lacking.A long time ago, I submitted a "vc-svn" but there was already one there. My experience was positive, and I'd be happy to do it again, and more than happy to sign FSF docs.I've never looked into it.I don't know what it isEmail patch management and copyright assignment are too cumbersome.Mailing lists are antiquated and make contributing difficult.I've submitted code before, and it has taken multiple months to even get a response (~6 months later, I got a response saying "do you use this code?" for a contribution that added missing hooks, where similar hooks already existed, just these ones were actually missing; I _do_ regularly use a patched version myself because there is no other way to conveniently get control at those points; nonetheless, the patch is not yet merged, because I was asked to sign FSF assignment form, which I did, and got no response, and the other side, where I pointed out the use cases, and it seems (at least elsewhere) people agree those hooks are useful, there is no progress; it has now been years since then, so I've basically given up on contributing back to anything FSF related, because it appears there are _tons_ of bureaucratic layers, for what is essentially a _straightforward_ contribution, and worse, there is literally no response; not even something like "no we won't accept this" or "here's a rewritten version" or "this is good, but this needs change" or any sort of feedback whatsoever. I see the mailing lists also only restricted to the same few names over and over, people who are already part of the "cabal". Overall, has put me _extremely_ off from contributing to "free-software". And this is coming from someone who is otherwise a prolific open-source contributor)Pretty smoothI don’t know it myself but heard that not supporting GitHub/GitLab functionality seems to be a blocker for package creators who consequently prefer MELPAPolitics (assignment, FSF backwards definition of "freedom" and its ramifications), blathering and ego trips prevail over rational discussion.It’s a bit tedious to set up.I like the email- and text-centric development workflow.I have seen that there is some discussion on the subject of emacs traditional mailing list development as opposed to github-like pull request development. As an outsider I've wondered: is it really not possible to create an emacs package to translate the pull request / acceptance into the mail list and vise-versa? It's a difference in preference, but people seem to treat it as though their way is always superior.The ideas about moving towards a development platform like Codeberg or at least Gitlab should be implemented rather sooner than later.Once I started doing it, I realized it's actually much easier than the Github process.works okI once asked for a code change to Emacs' source code. I even sent the diff to the mailing list, where it (and the problem it solved) was promptly ignored. Since then, I just use the diff before compiling every new version. And I unsubscribed from the mailing list, of course.Oh yes, I certainly do have feedback. FSF policy is as follows: 1. Emacs accepts public domain contributions. 2. Emacs does not accept public domain contributions. 3. Public domain doesn't exist. 4. The correct procedure for making public domain contributions is to first commit suicide, and then wait 75 years. I daresay the world would be significantly improved if the FSF's lawyers themselves would immediately make some public domain contributions, per the contribution procedure that they insist on.Have never seriously considered it due to my schedule.I think signing the FSF copyright assignment paperwork would be in conflict with my employment contract.Paperwork is annoying, and emacs-devel is insufferable with very few exceptionsNo feedback.I have some enhancements I'd like to contribute to some fairly core code, but I expect that the employer sign-off on the FSF assignment will be a hurdle.I think the copyright assignment requirement for ELPA is absurd and I won't contribute to packages in ELPA for that reason.The assignment is a hassle, as is having to deal with the mailing list when you are unfamiliar with the process.It seems really hard.It seems complicated, and I have never triedIt's far too burdensome. I've also had substantial work, that fixed a documented bug and that was "approved" by the maintainers, languish in limbo for a long time. This all reduces the incentives to contributeIt would be nice if the assignment process was faster (but still present - I value monolithic copyright in the hands of the FSF).I had to obtain FSF copyright assignment and my change ended up being more complicated than expected. So the maintainer just implemented it.Yes, the email-workflow is great!Nothing in particular. I have my FSF assignment, and if the maintainer prefers a patch attached to an email instead of a pull request, I'm fine with it.worked wellIt's slow but steady.Yes i just got some in system crafters Discord server, i didn't ask for it and i do not know why that person sent that but he/she did.never heard of ELPAEmail-based workflow and negative stories I've heard of people contributingNo, it was pretty smoothI really value emacs's and the FSF's philosophical stances, and the approaches they take to retain community ownership, and a steady, stable project. I would not want to lose that. At the same time, the barriers to contributing seem insurmountable at times, and some of the tools selected seem to contribute to that. I often wonder if we conflate the age of tools and processes with their ability to serve our projects needs. I would like to see us continue to take a conservative approach to adopting new things, but not so conservative that we remain on things with a high barrier to entry, nor so conservative that we ignore input like this.The email centered flow, always puts me off from contributing. The rare times I do is because a issue is so personally annoying I'd be willing to put up with the email process to have this fix and or feature in.Using github/gitlab/sourcehut might be a bit more beginner-friendlyShould there be a web form to fill in online other than asking for forms every new comtributors come in?The contribution process seems OK to me.code review (melpa)I would like an overview of the architecture and design of the C side of EmacsI have selected "never" for the previous question, but I'm going to get involved into Emacs development soon. And I totally don't mind the process it requires - actually, I think it's good way to sift "modern" devs who can't tell the difference between git and GitHub (I'm obviously exaggregating here, but you get the point). Also, review by email is far more scalable than e.g. GitHub PRs.It's very painless and easy as I don't have an employer who claims ownership of any and all code I write.Signing FSF paperwork is a non-starter for me. I stopped contributing to Org mode because of that. A CLA would be a better option.Getting the FSF copyright assignment done took 2 months to complete (20220223-20220419). Which seemed to be excessive.not so farNot interested for little gainThe review experience is great. The copyright assignment process is not; it needs to be simplified or abandoned.I contributed a small bit to Emacs many years ago. The procedure was complicated at the time, mostly due to the copyright transfer requirement. Maybe it has improved since then.Why no I haven't.N/aYes / dont understand the questionI attempted when I wasn't affiliated with any institution and was turned down. My next institution have a policy of not signing such documents and have in contract that they have no claim to my code, i was told i had to get it signed anyway.I don't even know where to start.It lacks a continuous integration system where every patch would be automatically checked.I will never do the FSF paperwork, on principle.GitLab or a similar open forge would be a lot friendlier. I have one or two bugs I've never gotten around to filing because previous bugs I've filed got no response and without going through the paperwork process I wouldn't be able to get any fix I wrote myself merged.Org maintainers never respond to my contribution.assignment waste time but it's understandable and code review is essentialNo feedback; it was quick and painless for me. Disclaimer: I'm self employed and no longer a student at any university either -- that probably made the paperwork way easier for me.keep up the great workBureaucracy destroys the soulI don't know anything about it.Still trying to find the paperwork and where to send it. I find it baffling why we are still doing such an archaic practice as emailing templates that are somewhere in a repository ...The process looks daunting. While I've contributed through mailing lists before and know it's not actually hard, it still requires some research on proper etiquette. The biggest barrier is FSF assignment, which I'm not particularly keen on.NopePeople are quick responsive and it is not so complicated but print then sign than scan some paperwork is not great and not encouraging me for contributing.dmitry gutov was super helpful and kindThe barriers seem high compared but not sure its a bad thing, might be goodIt doesn't bother me. I just push changes, I don't care about attribution or copyright when I am contributing to someone else's code base.naThe assignment process is a major pain and feels like gatekeeping at this point. I'm not a fan of the review on the mailing list either, it is a rather punishing process. The insistence on the poorly specified commit message format deviating from any other FLOSS project I've worked with doesn't help either.Wanna use other git repo like GitHub or gitlabThe FSF assignment is a significant barrier to entry.The FSF assignment is much more convenient than I realized, in particular, it can be done electronically and does not requiring mailing physicial paper. This does not seem to be widely known and I kept from doing it for years because I thought it was harder.Abandon paperwork..英語が書けないのでどうしようもありません。my impression is that the process is hostile and onerousThe process to contribute to GNU Emacs is not smooth, some people are harsh on their comments in the mailing list, some threads do not get responses, some patches take a long time to get feedback, sometimes it's not clear the guidelines about some features or design decisionsI don't think I have built something so useful yet.Discussion feels not so visible / I don't have the time to read mailing lists since I'm not a primary contributor.I try not to think about it too much. I just want to enjoy the time I have.Nope.I'd rather write off my cooyright to an international organisation as I consider FSF too heavily focused on US/North America. Preferably an FSF International which FSF (renamed to FSF North America), FSFE, etc.. could join.It's very good. I published a small package I wrote and got a lot of help to get it to pass the review, from the reviewers themselves.Too cumbersome. Not worth the hassle to go through the process at work to get clearance.Yes, the mailing list worked with me and provided insightful feedback. RMS, Eli, the Stephens, and others were all friendly and helpful. Craig Topham guided me through the FSF assignment process.I tried obtaining FSF and that was hard. I don't fully understand how to work with email development mailing list (I really should do this, the barrier is just high enough so that I've delayed it for years)Maybe the Gnus development mailing list should be moved to gnus.org.Copyright assignment is a huge barrier to all.Pull requests would be much nicer. It doesn't need to be GitHub, but a similar flow would be excellent.The process feels very old fashion and just having to think about it is enough to turn me to submitting my packages to MELPA insteadEmployment agreement is a hurdle, even though it appears to illegally (under NY state law) attempt to claim ownership of ideas/software I develop outside of work that are not part of my job, and prevent me from participating in an otherwise legal hobby activity, such as contributing code to FSF projects. Since I can't guarantee they won't sue FSF, or that they wouldn't win such a suit (not a lot of precedent due to arbitration clauses), the FSF can't accept my assignment form. It's unfortunate that NY Labor Law is effectively circumvented and third parties like the FSF are deprived of contributions.I have been waiting on getting a FSF assignment for almost a year now, blocking me from contributing. Issue is that the disclaimer note from my employer needs to be reviewed.The FSF Assignment is a painDon't assume users know what they're doing; curt responses, while maybe accurate of the situation, come off as if the user should know. And, if a contributer is using a well-known Emacs package, don't simply reply with, "I don't know what that does," when, clearly, they thought it was a wrapper and shouldn't've disrupted anything. They're donating their time and you are the expert; even if you avoid said packages, many new users don't so just saying, "I don't know," indicates your not interested in the person's help.Review of changes should be postponed further when no expert is available to review them. See the original fix for bug#10867 for an example of why, which actually broke Input Method support for many users, but was installed due to a lack of knowledgeable X developers at the time it was submitted.I got my feedback when my assignment went thru. I also submitted a small eshell patch on the debbugs bug tracker.FSF signature is too heavy to contribute.I can't obtain FSF assignment papers. I'm allowed to contribute to free software though.In late 90s a lot of people were dicks.I would prefer the traditional github workflow over mailing lists and fsf assignmentStuck on paperwork from work.Most contracts with companies make OSS contributions annoying in the first place. I'm glad some folks are able to contribute, but in my experience most companies want to own all your code, and will decline allowing these types of contributions.Contributors are very expert, so it's hard to be on par. I don't know what would be accepted in the core vs. what should be outside.Forge pleaseIf you want contributions can you make their production built-in to the creation of any customization?The copyright assignment and legal name (doxing) policy is directly responsible for a significant lack of contributions. One can easily ask in Libera's IRC #emacs channel and observe that for themselves.Emacs itself should be on github or gitlab, not gnu's busted system.The barrier to entry is high. The dev mailing list looks like it is filled with noise, so I am hesitant to subscribe to it. I'm working on FSF assignment but only so I can contribute bug fixes.I understand the rationale behind the process, but I never had the chance to contribute.Overall, a pleasant experience.Signatures are too cumbersome.No...The biggest problem is getting an employer to sign the copyright waiver.I wouldn't do CLAs or copyright assignment. So I wouldn't contribute to projects requiring it.I would never assign copyright to the FSFNeed web based companion to bug list for visualizing changes between patch-set iterationstedious but the code feedback was good.If it were not for the FSF assignment process, I would be actively contributing to Emacs. I know others in a similar position.I am too new a user, but I would like to contribute when I get the skills to do so.More documentation for beginners including how to send patches, copyright assignment and etc...I wish the bug tracker (debbugs) were easier to use; specifically, that it would have a web interface to most of its functionality.Signing the form is extremely frustrating. The process of getting my employer to sign the form is quite onerous, but is viewed by at least one maintainer as not an issue, as "nobody has ever had a problem with it". I've had a problem. I've had a boss refuse to sign the form for over a year; I had to change teams to get management to agree to sign the form. Even the instructions for the copyright assignment are confusing! The user is instructed to email the emacs mailing list. Then, random people give different, contradictory instructions. It turns out one has to email a *different* email. In terms of contributing, it's also frustrating. The contribution process via email invites drop-ins, and often it's not clear who needs to be convinced of something. Or, even, what the criteria are for something being included in Emacs.FSF assignment is only as painful as running the scanner.I don't know the process of submitting to GNU ELPA. I wish I didn't have to search for this information online.It's a bit different than git(hu|la)b reviews, but it's nice. Sometimes packages get ignored for a long time, and there's no way of seeing if a reviewer has seen your patch. In git(hu|la)b, a simple thumbs up is often enough to know that it has been seen.I didn't try submit packages to ELPA, someone took my packages and added them though.The mailing list contribution workflow is a barrier for me. Being unable to "rebase" or "amend" emailed patches, or edit out mistakes/undecipherable brain dumps in verbal responses, makes me nervous that any contribution of mine will come with me spamming amendment replies; something I wouldn't wish on my worst enemies. It also doesn't help me that these mailing lists are difficult to peruse and search without a dedicated frontend.Yes, debbugsFSF assignment took quite a long time, and was hard for me without a printerSomeone on emacs-devel reviewed my ELPA package and helped with the publishing processHaven't bothered trying due to the ancient email-based stuff.
Could you list some of your favourite packages? (comma-separated) Stringmagitorg-modeMagitorgorg-mode, magitmagit, org-modeOrg-modeorg-roamevilOrglsp-modemagit, lsp-modemagit,org-modemagit, helmorg-mode, org-roammagit,lsp-modemagit, lsp-mode, org-modemagit, evilmagit, orgOrg, org-roamauctexhelmorg, magitOrg-mode.lspmagit,projectileOrg-roamlsp-mode, org-modeEvilorg modeOrg modeciderSlimeorg-mode, magit, lsp-modeAuctexelphernyan-modeDenoteEvil-modeCIDEROrg-mode, org-roamuse-package, org-roamorg-mode, magit, evilMagit, evil, orgvmMagit, ivy, swiper, projectileMagit, Projectilemeowprojectileslimetelega.elmagit, eglot, org-modeconsultmagit,evil,lsp-modeOrg Modeeglot, magitmagit org-modemagit, orgmode, mu4emagit, diredorg-mode, evil-mode, which-key, magit, org-drillmagit,org-roamorg, lspmagit, eglotMagit, OrgMagit, orgTidemagit,eglotOrg-mode, magitweb-modeMagit, org-modemagit,org,eglotevil, magitorgmode, magitmagit, mu4eorg-roam, magitvertico, corfumagit, elpyorg-mode, evilorgmodeEmacs-w3morg, magit, projectileorg, magit, trampidomagit, org-roammagit, org-mode, eglot, lsp-modevertico,consult,marginalia,orderless,embark,corfu,cape,tempel,eglotOrg-roam, lsp, evileglottreemacsmagit, ciderorg-roam, lsp-modeorg-mode, magit, helm, tramp, dired, smartparensmagit, eglot, emacs-vtermEvil, org, notmuch, olivettimagit, evil, lsp-mode, undo-tree, vertico, company, org-modeorg-mode (does that count?), org-roam, org-modern, org-fragtog, god-mode (this is a godsend), ivy, counsel, typo-mode, pdf-tools, novI run vanilla so I don't have any packages installed.vterm, eshell, ess, eww, org-mode, dirvish, beaconbookiez, epkg, flycheck, no-littering, paredit, undo-tree, which-keys.el,f.el,dash.elorgmode, vertico, corfu, code-cells, eglotMagit, SLIME (used to develop in CL), multiple-cursors, orgMagic,EglotSLIMEmagit, consult, embark, vertico, auctex, eglot,magit, dirvish, modus-themes, vtermmagit, magit, magit, magit, magit.magit, helm, tide, tramp, orgslime, geiser-mit, auctexmagit, projectilemagit,lsp-bridge,evilTramppowerline, autocomplete, google-translate, neotree, syslog-mode, go-mode, json-modeorg, magit, lsp, web-modereverse-im, general, hydra, projectile, lsp-mode, evil-nerd-commenter, vtermHelm, crux, magit, projectile, org, org-roamorg-mode, magit, org-babel, evil, helmanaphora, csv-mode, debian-el, markdown-mode, slime, w3mEliminate the stupid word limit here!lsp-mode, elpher, gemini-mode, visual-fill-column-modeevil,ivymagit,evil,projectile,emacs-lspDenote, modus-themes, auto-package-update, which-key, undo-tree, dired, all-the-icons, paren, rainbow-delimiters, google-translatexah-fly-keys, xah-html-mode, xah-css-mode, xah-elisp-mode, xah-find, xah-get-thing, xah-lookup, xah-math-input, expand-region, smexembark,consult,corfu,marginalia,vertico,orderless,org,magit,system-packages,tree-sitterorg, lsp, company, vertico, consult, marginalia, org-roam, magit, SMerge, notmuchmagit, legder-modeorg-mode, magit, vertico, consult, embark, evil-mode, org-roam, jupyter, projectilemagit,rg,vertico,consult,generaldirenv, editorconfig, flycheck, lsp, lua-mode, markdown-mode, smartparens-config, unfill, yaml-modeorg-roam, org-babel, evil, magitevil,magit,verticoIvy, magit, projectile, evil, lispyorg, mu, magit, lspOrg mode, magit, ledger mode, CSV mode, vertico / consult / embark / marginaliaHonestly, I don't have any. Why would I have a favourite package when every package does something different?magit, org, eglot,org-mode, general,evileglot, magit, flymakehelm, leaf, howm, swiper, lsp-mode,org-mode, magit, pdf-tools, mu4e. Used to really like MH-E but haven't used it in a long while.magit,lsp,cidertramp, org-mode, flyspell-mode, flycheck-mode, helm, slimerust-mode, flycheck-modevertico,marginalia,selectrum,magit,filetree,lsp,eglotlsp-mode, counsel, swiper, magitevil, hydra, magit, eyebrowse, vterm, org-roam, direnv, mu4e, elfeedPerspective,org-modemagit, org-mode, exwm, consult, vertico, undo-treedocker, projectile, swiper, vterm, wgrep, eingnus, org, magit, dired, tramp, ement, nxml-mode, pdf-tools, eldoc, eglotMagit, eglot, dired, multiple cursors, s,org-roam, magit, helm, org-modelispy, org-mode, org-roamgod-mode, org-modelsp-mode,eglot,use-package,magit,tuaregevil,use-package,lsp-mode,org-roam,magitvertico, consult, embark, org-roam, eglotWhich-keyLsp-mode, lsp-ui-mode, slime (back in the day), tramp (back in the day), magitOrg-mode, Corfu, Olivetti, ModusOrg-roam, org-babel, ef-themesSlime, paredit, org-modemagit,verilog-modelsp-mode, cider, magit, vertico, consult, marginalia, project.el, ement, general.el, straightmagit, lsp/eglot, treemacs, org, doom mode-lineOrg-Mode, Magit, Yasnippit, Rest Client, Tramp, Eglot, Company/Helm, OSX-dictionary, treemacs, which-keymagit, companyAce-window;magit, which-key, evilmagit, org, org-roam, beancount, org-bibtex, org-journal, cider, lsp, helm, smartparenseglot, lsp-mode, org, evilmagit, use-package, elpa, multiple-cursors, projectile,evil,magit,eglot,orgdesktop, which-key, vertico, consult, evil, use-package, magit, org, company, denotemagit, org mode, eldoc, ivy, company, ef-themes, use-packagevertico, swiger, company, rainbowdelimiter, dired, org-contrib, which-key, projectile, ibuffermagit, vertico, consult, orderless, corfu, use-package, which-key, marginalia, lsp-mode, multiple-cursorsevil, evil-collection, evil-fringe-mark, yasnippet, tramp, evil-visualstar, evil-commentary, evil-owl, neotreeevil,cidermagit, rustic, smex, companymagit,dumb-jumpmagit, ivy, lsp-mode, org-modeEvil, magitranger.el,mu4e,dirvishorg, evil, magit, projectile, smex, ivy, companyvertico, projectile, magit, lspOrg, Merlin, Tuaregox-twbs, rec-mode, forth-mode, magit, dashboard, wanderlust, mu4e, yasnippets, vtermMagit, evil-mode, hydra, projectile, swipermagit, TRAMP, Org, straight, vertico, Elpycider, clojure-mode, undo-tree, pareditmagit, eglot, evil, corfu, cider, package.el, consultVterm, org-mode, magit, kubernetes-el, helm-ag, dired, helmmagit, doommagit, mu4e, projectile, org-mode, markdown-modewhich-key,eglotPDF-Tools, Org-mode, Auctex, Dired, V-termMagit,mu4e,multiple-cursors,helm-bibtex,org-mode (now built in), which-key, yaml-modepo-mode, ef-themes, leaf, nxml, idris2-mode, flycheckOrg, pdf-tools, yasnippet, verticomagit, treemacs, sly,slynkmagit, treemacs, minimapeglot,elfeed,ement.el,evil,magit,modus-themes,mu4e,org,symex.el,verticoMagit, org mode, mu4e,deadgrep, dtrt-indent, dumb-jump, eglot, elfeed, magit, nov, org, smart-tabs-mode, vtermDenote, vertico, orderless, elfeedorg, magit, project, vertico, orderlessOrg mode, Magit, mu4e, LispySLIME LatexMagit,exwm,affe,consult,org,corfu,default-text-scalemagit,org-mode,lspmagit,sly,ispell,evil,helmMagit, Dracula-theme,markdownIedit, magitOrg-Mode, Avy, Helm, Smartparens, Company, Flycheck, Magitprojectile,lsp,tree-sitter,vertico,embark,consult,ivy,org,pdf-toolsevil,general,org-mode,corfu,which-keyvertico,marginalia,mu4e,use-package,no-littering,restclient,denote,magitParedit, C-mode, Go-mode, LSP integrationmagit,direnvMeow, org-transclusion, rimeorg-mode, fold-thisbbdb,elfeed,elpher,magit,orgMagit, diff-hl, helmuse-package magit <3 auctex rust-mode paredit ace-modeproject.el,evil,deadgrep,doom-themes,undo-fu,magit,magit-delta,paredit,consult,orgOrg mode, magit, ledger-mode, org-ref, org-super-agendaperspectives, projectile, org-super-agenda, orgHelm (helm-for-files!), Evil, Org-mode, Avy, Mu4e, Ement, Sly, Elfeedmagit, org-mode, tide, prettier, tramp, diredcider, evil, projectile, ivy, clojure-mode, parinfer-rust-modeorg-mode, cperl-mode, gnus, bbdbOrg, Markdown-mode, Emacspeak, nnredditgeiser, smartparens, consult, marginaliamagit, lsp-mode, company, org-mode, flycheck, vertico et al, tree-sitter, use-package, no-littering, apheleiaorg, magit, ivy, jupyter, eglot, git-gutterMagit, org-mode, dired, lsppdf-toolsorg-mode, magit, eshell, erc, projectilebufferlo,wgrep,minions,vterm,eglot,dtrt-indent,magit,pdf-toolsavy, ace-window, lspI don't really use any packages that I can think of.lsp-mode, dap-mode, dart-mode, etc etcmagit, org mode, mu4e, helm, elpy, org slack with slack mode, Calc, paradox, tramp, multiple cursor (or Mc?)cider, magitperspective, magit, projectile, calfw, calibredb, pdf-tools, elfeed, deft, paredit, slimeuse-package, magit, elpy, ivyevil, org-mode, geiser, cider, sly, magitAuctex, org-mode, helm,eglot, project, magit, ssh-tunnels,org-mode, ESS, polymode, yas snippetlsp, projectile, magituse-package, ess, eglot, lsp-mode, elpy, slime, sly, cider, geiser, theme-anchorwhich-key, magit, evilORG-mode,symex.el, cidermagit, cider, clojure-mode, company, lsp-mode, rust-mode, flymakegnus, clojure-modemagit,ranger.el,lspexec-path-from-shell,diminish,sudo-edit,lsp-mode,vertico,orderless,consult,marginaliamagit, org-mode, yafoldingorg-mode,adoc-mode,yaml-mode,yafoldingdeft, flycheck, helm, magit, org, ox-pandoc, projectile, pyvenv, rg, vtermevil, org-mode, magitmagit, eglot, vc, erc, paradoxOrg mode, evilEglot, Tramp, elpyorg, auto-complete, magichide-lines,editorconfig,magit,browse-url-dwim,yasnippet,highlight-parentheses,which-key,multiple-cursors,hydra,all-the-iconsMagit, lsp, mu4eorg mode, magit, tramp, term, tramp-termorg-mode, mu4e, completion frameworks (helm, ivy, vertico & friends), magitorg-mode, org-roam, eglotmagit, use-package, org-modeorg-mode, magit, evil, projectile, helm, yasnippet, elfeedevil, org-mode, avy, org-roam, writeroom-mode,org-mode,magit,projectile,vterm,slime,restclientprojectile, which-key, magitorg,evil,magit,undo-tree,hydra,ivysly,cider,smartparens,vterm,magit,git-identity,org-modevhdl-mode, org-modevterm, magit, org, link-hint, pabbrev, code-reviewCircadiani, org-roam, lsp-mode, magitmagit, org-mode, eglotslime,org-mode,rainbow-delimiters,pareditmagit, helpful, ivyEvil, consult, dired-copy-paste, avy, evil-tex, ess, affe, vtermevil, git-gutter-fringe, orgtwittering-modelsp, company-mode, verticoivy, avy, counsel, magit, diff-hl, denote, modus-themes, ef-themes, fontaine, orgall-the-icons, helm, leaf, skk, anythingProjectile, Magit, Eglot, Ivy, and Counselauctex, geisercompany,yasnippet,haskell-mode,windmove,auctex,flycheckmagit, org, mu4e, verticoMagit Helm Projectilemodus-themes, ef-themes, vertico, orderless, corfuorg-mode, magit, pocket-reader, persistent-scratch, multiple-cursors, mixed-pitch, expand-region, avydired, vc, org, exwm, embark, consult, vertico, geiser, mu4eOrg-mode, auctex, ivyorg-roam, helm, projectile, magit, org-babelmagit,treemacs,,counsel,org-mode,eglot,lsp-modeorg-roam, embark, vertico, evilOrg mode, magic, tramp, calcorg-mode,magit,auctex,eglotAuCTeXcitre, consult, corfu, elpa-mirror, magit, modus-themes, org-super-agenda, pyim, tempel, verticoEvil, Olivetti, org, straight, companyorg-mode, slime, gnus, magit, transientorg-mode, notmuch, avy, Company,LSP, orgorg-mode, bbdb, gnuslap,evil,magituse-package, lsp-mode, rustic, yasnippet, projectile, deadgrep, magit, tree-sitterorg-mode org-roam org-roam-ui cfw:calendarhelm, lsp-mode, flycheckorg-mode, verb-mode, password-store, rg.el, vterm, tree-sitter, yasnippet, eglot.magit, undo-treehelpful, delsel, smartparens, undohist, wgrep, saveplace, orderless, embark, company, transpose-framecompany, w3m, web-modeEmacs speaks statistics (I need to use SAS), elpy, flycheck, magit, helm, org, trampMagit, org, projectilehelm-swoop,helm,magitorg, mu4e, ledger-mode, denote, calibredbparedit, straight itself of course, god-mode, auto-capitalize-mode, notmuch, rcirc, markdown-modeorg mode, todoist, elfeed, dired, org-superstar,ivy, counsel, swiper, magit, expand-region, lsp-mode, undo-tree, vtermexwm, dired, org, outline, vterm, modus-themesorg-mode, lsp-mode, magit, org-roamOrg Mode, Deft, Dired, Calc, Ledger Mode, Embark, Consult, Marginalia, Langtool, Tramporg,notmuchevil, ciderMagit, Helm, LSPMagit,meow,eglotLedger-modeMagit,Org-mode,Vtermmagit, raku-mode, plantuml-mode, slimeorg-mode, org-roam, pdf-tools, evil-mode, magitorg-mode, trampmagit, org-mode, lsp-mode, rgevil, evil-leader, ivy, magit, org, org-roam, paredit, rainbow-delimiters, use-package, projectiledired, vc, ibuffer, vterm, eshellOrg, Babel, Vertico, Consult, Org-Roam, TRAMP, Magit, Olivetti, DiredMagit, org-mode, SLIMEProbably evil mode, but also MagitBeacon, Org mode, hindent, slimefireplace, page-break-lines, flymakeorg-journal, pdf-tools, cyberpunk-theme, elfeedevil, smartparens, rainbow-delimiters, rainbow-identifiers, repeatable-motion, helm, magitorg-mode, evil, org-roammagit, lsp, ido,org-modeEglot, Slime, lisp-mode, java-modeorg-mode, magit, geiser, programming language modes, neotree, undo-tree-mode,use-package, flymake, flycheck, magit, golden-ratio, ido-vertical-mode, yasnippetOrg, avy-jumpmagit,shared-buffer,lspcider, golden-ratio, projectile, magit,selectrum, consulteshell,org-mode,dired,mu4e,ercmagit, org, evil, undo-tree, avy, flycheck, counsel, company, lsp-modeorg,evil,org-mode, emacs-ess, vtermmagit, eglot, use-package, straight, selectrum, apheliaXah-fly-keys,Magit,Org-mode,Ivy,Flycheck,Company,Cidermagit, lsp-mode, org-mode, projectile, ivy, flycheck, counsel, vtermorg-mode, magit, dired, eshell, tramp, gnus, helm, ivy, ... (the ones mentioned below actually)ercVC, RMAIL, Diredorg-mode, emms, elfeed, consult, embark,vertico, magitIbufferVterm, dwim, spartparens, undo-tree, yasnippet, elfeed, magit, pdf-toolsassume this is external packages - Magit, reformatter, elfeed, dumb-jump, ledgerI use few add-on packages these days.Slime, pareditmagit, helm,Way too many to mention, sorry... But what is important - many of them are built-ins.multiple-cursors.el, lsp, magitAuctex, Citar, ESS, Magit, Org, Org-journal, Org-static-blog, Tempel, Yasnippetelpy, magit, yasnippet, pareditgolangmagit, elpy, ido-mode, org-mode, trampOrgmode, Org-Babel, Magit, Eglot, Auctex, Gnusauctex, org-roam, slymagit,org-mode,ledger-modeevil-mode, magit, parinfer, vertico, companymeow, pdf-tools, helpfuldashboard.el, mu4e, ledger-mode, vertico, auctex, marginalia, projectile, whichkey, orderless, pareditOrg-mode, lsp-mode, cedet, elpy, org-roam, vertico, magitpython-mode,linum-modemagit, projectile, flycheck, company, use-package, dired, helm, generalorg, org-roam, org-super-agenda, lsp, magit, olivettignus, tramp, org-mode, notmuchWhich-key Tidemagit,lsp-mode,rggemini-modeorg, org-roam, org-roam-ui, biblioMagit,mu4e,orgmodeorg,org-roam,lsp-mode,helm,treesitter,slimepython-mode,auctex,zenburn-theme,solarized-theme,magit,essorg-mode,magitmagit,evil,vertico,marginalia,lsp-mode,projectilegnusmagit, cider, evil, helm, org-modeUndo-treeorg, pass, mu4e, ivy, rainbow, company, persist, swiper, magit, org-bulletsorg-mode, magit, org-ql, mu4eembark,corfu,magit,vterm,pdf-tools,logosevil-mode, magit, eglotmagit, ido, undo-tree, latexmarkdown-mode, pandoc-mode,web-mode, rinari, ruby-extra-highlight, ruby-electric, php-boris, php-mode, racer material-theme,better-defaultsMagit, Orgmode, Eglot, Jupyter, Vertico, Consult, CorfuSwiperEvil, Citre, Mu4emagit,golden-ratio-modehelm,es-mode,magit,popup,smartparensorg, magit, use-package, projectile, helm, flycheck, ag, recentf, rainboworg-mode,helm,chrono-helmorg-mode, go-mode, magitVertico, which-key, eglot, corfu, orderlessprojectile, slime, ESS, tuareg, geiser, lsp-modeorg-mode, evil, direnv, magit, org-roam, treemacs, emms, ob-http, olivetti, elpherparedit,company,company-irony,flycheckorg-modern, org-roam, lispy, lispyvilleMagit, Cider, org-mode, projectile, ivy, paredit, lspmarkdown-moderanger,org-mode,magit,zeal-at-point,direnvlsp-mode, dap-mode, anzu, avy, yasnippetmagit, org, flx-ido, neotree, rainbow-delimiterstramp, lsp-mode, helm, evil, which-key, tabspaces, flycheck, magit, cheatsheet, elfeedparedit,magit,SLIME,use-package,consult,selectrum,which-key,lsp-mode,Evil, Company, yas, slime, orgmagit,pdf-tools,org-fragtog,org-appearcompany-mode, eev, dtk, diatheke, tramp, zetteldeft, notdeft, mu4e, orgmode, etc...Magit, org-mode, doom-modeline, multiple-cursors, expand-region, volatile-highlights, persp-mode, which-key, evil-nerd-commenter, pcre2elorg, flycheck, multiple-cursors, solarized-thememagit, org, org-roam, org-roam-ui, evil, lsp, org-everywhere, magit, and magitEvil, org-modedockerfile-mode, go-mode, gruvbox-theme, helm, helm-swoop, markdown-mode, python-mode, rust-modemagit, eglot, embark, corfu, cider, verticoevil, magit, org, ivy, company, vterm, telegaavy, consult, project.el, ace-windowmagit, org, ivy, company, ripgrep, wgrep, dumb-jumpOrg-mode, Magit, Dired, Denote, org-journal, ox-hugoMagit,Projectile,vertico,lsp-modemagit,lsp-mode,evilorg,magit,slime/sly,eglotOrg, magit,org-roam, org-noter, matlab-mode, org-modern, org-roam-bibtex, dap-mode, lsp, lsp-treemacs, svg-tag-modemagit, lsp, corfu, which-key, projectile, vterm, ace-window, org, org-roamEvil, magit, ivy, general, which-keyfountain-mode, olivetti, markdown-mode, deft, exec-path-from-shell, adaptive-wrap, csv-mode, browse-kill-ringsetup.el, straight.el, lsp-bridge, meow, magitExtensions for org mode, markdown, format conversionMagit, org-mode, denote, dired, corfu, orderlessproof-general, org-roam, vterm, org-pomodoro, auctex, mu4e, modus-themes, avy, lsp, olivettigeiser, company, ggtags, lsp-mode, themesorg, org-roam, org-cite, citar, org-roam-cite, tab-bar, tabspaces, lsp-mode, eglot tree-sitter icomplete project use-package multiple-cursors magit which-key pdf-tools nov.el calibredb restclient smart-parens spell-fu elfeed notmuch envrc solarized-theme code-review haskell-mode vterm ox-hugoauctex, ghosttext (websocket)Dired,magit,markdown,prog,latex,eglotslime,cider,magit,paredit,impatient-mode,git-timemachineemacs-lsp, vertico, evillsp-mode, ivy/concur/swiper, magitLsp-mode,org,magitcompany, flycheck, magit, pyvenv, python-black, py-isortlsp-mode, ivy, projectile, company, magit, diff-hl, which-key, multiple-cursors, web-mode, undo-treeconsult,embark,magit,lispyville,devdocs,avyorg-mode, eglot, mu4eEvil, hydra, posframewgrep,window-numbering,better-defaults,elpy,ivy,swiper,company,web-mode,find-file-in-project,rgCIDER, magit, flx, flx-ido, typescript-mode, tide, ruby-mode, lsp, company, projectileMagit, Org, Notmuch, Modus-themes, S.el, General, FFAP (built-in), Pass.magit, elfeed, org-modemagit, rustic, tide, ligature, nano, lsp, ranger, deadgrep, olivettithe previous question wouldn't allow a null answer.magit, kubernetes-mode, lsp-mode, eshell, ewwevil, magit, rainbow-delimiters, org-journalmagit, whitespace, various language modes, verticoOrderless, vertico, embark, magit, denote, eglot, corfu, editorconfig, avy, htmlizehelm,magit,php-mode,projectile,trampMagit, projectile, straight, git forgecperl-mode, please just replace perl-mode with cperl-mode I wasted literally years using perl-modeevil-mode, company-modeMagit, lsp modesMagit, Avy, Vertico, Writegood, LangtoolMagit, Perspectiveprojectile, helm, lsp, hydra, ace-windoworg-mode, yasnippet, evil, helm, projectilecompany,magit,lsp-mode,flycheck,diff-hlorg-mode, magit, pdf-tools, sly, dirvish, evil, vertico, consultorg-mode, org-roam, magit, gruvbox-material,magit, deft, org-mode, nxmlmagit,projectile,helm,lsp-modeSpacemacs defaults: evil, helm, magit, org-modeEvil, evil-sneak, avy, evil-avy, magit, org-modeOrg, elfeed, YASnippetjulia-vterm, ob-julia-vterm, vterm, org, eglot, pdf-toolscider i miss vmorg,magit,lsp-mode,evil-mode,ivy,elfeed,ace-jump-modeMagit, org, lsp support, function searcheglot, diff-hl, denote, orgorg, evil, magit, org-super-agenda, eshellemms, elfeed, zettelkasten, dictionary, elpher, german-holidaysExternal: AUCTeX, CIDER, Orderless. Built-ins: Dired, Modus Themes, Eglot.Sly, Corfu, Orderless, pdf-tools,org, mu4e, pdf-tools, auctex, magit, ebiborg-roam,magitmagit, restclient.el, lsp-mode, orgrequest-mode, magit, org-modeOrg, ggtags, xcscope,helm, cider, paredit, ace-windowjulia-snail, org-modeorg-mode,evil,ivyhelm, magit, projectile, orgmodemu4e, evil, eglotevil, flycheck, help, projectile, magitorg-mode is the one I use most these days.magit, lsp-mode, flycheck, multiple-cursors, prettier-js, try, undo-treeorg-mode, magit, forge, projectile, treesitter, selectrum, consultLsp, projectile, ivy, doomlinemode, maggithelm-swoop, ag-project, elscreen, lispy-mode, hydra, wgrep, web-mode, indent-toolsorg-roam, magit, hyperbole, lsp-mode, which-key, embark, general, avy, treemacs, all-the-iconsConsult, vertico, lsp-mode, tree-sitter, magitmagit, magit, magit, did-i-mention-magit, multiple-cursors, git-cutter, centaur-tabs, avyparedit, org, cidermagit,cider,projectileEglot, Company, Orgmagit, flycheck, pareditevil,sly,vertico,yasnippet,paredit,companylsp-mode, eglot, tree-sittermagit, org, org-roam, flycheck, robeslime, cider, eglot, tramp, agda2-mode, magitcounsel, ivy, org, ansible-mode, lilypond-modeMagit, Org, dired, vterm, eshell, vertico, deft, elfeed, lsp-moderestclient, fold-thisOrg-roam, org-ref, mu4e, auctex, magitOrg, Evil, Ivy, Which-keycider, clj-refactor, paredit, org-mode,elpher,god-mode,magit,paredit,slymagit, dante, evil-mode, flycheckmagit,lsp(It will take too much time to list all of them)go-test, evil, magitVertico, Projectile, Magitorg mode, magit, projectile, helm & counsel/ivy, rcirccompany-mode, auctex,ivy, avy, slime, magit, wgrep, lispy, multiple-cursors, expand-region, trampmagit, org, mu4e, projectile, elscreen, emmsemmselpy, markdown mode, zenburn themeEmacs Octave Support, AUCTeX, helm, MagitMagit, lsp-mode, prescient, avyOrg, auctexmagit,cider,org-mode,projectilelsp-mode, ivy, org-mode, slyI don't use any that I know ofmagit, treemacsess, magitmagit, docker,helm, helm-twitch, helm-pass, org, org-roam, org-journal, lspevil, org-mode, projectile, consult, vertico, magit, companyorg, magit, gnusorg-mode,magit,yasnippetslsp-mode,org-mode,vertico,general.elOrg-mode, Org-roam,CIDER, magit, org-mode, parinferAuctex,Flyspell,Magit,Projectile,Undo-treeorg,lsp-mode,eglot,magit,pdf-tools,companyvertico, eglot, orderless, vterm, multi-vterm, corfumu4e, orgpdf-tools, evil and evil-collection, mu4e, consultledger, diffview, python-modeorg, company, flycheck, selectrum or verticoOrg-mode Evil modedired, magit, vertico, consult, company, org-roam, lsp-mode, projectile,shackle, undo-tree, flycheck, wgrepOrg, magit, subed, hydraMagit, swiped, org, cantrip, anticsisearch-mb, puni, vertico, consult, diff-hl, citre, orgAce window, projectile, tramp, vterm, magitorg-mode, SLIME, CIDER, nyan-mode, telega, themesMagit, Eglot, Vertico, Orderless, Evil, General, Elfeed, Vterm, Notmuch, DenoteVertico, orderless, corfu, embark, magit, forge, org,projectOrg mode, magit, dired, tramporg-mode (ob-ipython, ox-reveal, org-mime, ...), mu4e, magit, smart-tabs-mode, helm, yasnippet, ace-windowStraight, org, org-roam, vulpea, telega, elfeedlsp-mode, magit, org-mode, org-roam, org-noter, dired+, general.el, company, yasnippet, evil-multieditOrg-mode, auctextramp, which-key, haskell-modedired-subtree, haskell-mode, elm-mode, yaml-modeevil, magit, lsp-mode, which-key, generalmarkdown-mode,hyperbole,companyMagit,eglotmagit, org-mode, tide, lsp-mode, web-mode, golden-ratio, yasnippetorg, magit, dired, mu4e, elfeed, consult. paredit, punivertico, geiser, magit, citarorderless, vertico, marginalia, embark, consult, dirvish, pdf-tools, org-roam, citar, popperorg, org-roam, straight, use-package, SLIME, LSP support, company, EVIL mode, Magityasnippet, projectile, trampmagit, key-chord, projectile, flycheck, which-key, elfeed, vertico, consult, orderless,I don't discover new packagesorgmode, mu4e, dired, elfeed, erc, magitvertico, consult, org-mode, evil-mode, magit, which-key, mu4e, vterm, doom-themes, doom-modelinemu4e, tramp, magit, elfeed, denoteI really only use computer language mode packages.eglot, web-mode, markdown-modewindresize, yasnippet, which-key, use-package, popup, lsp-ui, lsp-treemacs, elixir-mode, counsel-projectilecompany-modemagit, avy, ivy, counsel, swiper, paredit, lispy, agressive-indent-mode, company, sAUCTeX, Grammalectemagit, setup.el, embarktree-sitter,notmuch,eglot,tramporg, telega.elmagit,ws-butler,lspLedger-import, nano-emacs, ob-lilypondVertico, Perspective, Julia Snail, Dirvish, Denote, Org, Slime, Cider, Tide, Helmrestclient, org-mode, ace-windowelfeed,magit,org,outline-magic,ido-vertical-mode,dumb-jump,rpm-spec-mode,iflipb,company,pdf-toolselfeed, org-mode, notmuch, zetteldeft, org-roam, sly (for common lisp).Magit, Org, plantuml-mode, js2-mode, web-modeorg, org-roam, org-noter, helm, pdf-tools, yasnippetauctex, eglot,magit, flycheck, ido, projectile, smartparens, yasnippet, auto-completeorg-mode, magit, which-key, vertico, orderlessevil, undo-fu, gruvbox-themeOrg roam, org ref,org-mode, magit, olivetti-mode, use-package, lsp-mode, projectile.Magit, org, roam,Magit, avy, verticomagit, which-key, golden-ratiomagit, vertico, consult, which-key, ace-window, ws-butler, git-gutter, lsp-mode, multi-compilemagit,wgrep,avy,expand-region,embarkMagit, org mode, org roam, lsp modemagit, projectile, vertico, org, org-roam, vterm, eshell, lsp, apheleiacider, magit, consult, vertico, orderlessorg-mode, org-roam, evil, elfeed, lspMagit, org-mode, cider, projectile, counsel-*org-mode, org-babel, lsp-mode, projectile, magit, flycheck, flyspell, Windmove,auctex, org, cdlatexcompact-docstrings, evil, hl-todo, which-key, modus-themes, rainbow-mode, command-log-mode, org-ql, org-roamdeft, helm, magit, spacemacs-theme, orgroamlsp-mode, projectile, auctex, magit, vterm, helmEvil,counsel,avy,ivyorg-roam,avymagit,lsp-mode,slime,mu4e,org-modego-mode,graphql-mode,rust-mode,flycheck,json-mode,xquery-modebeacon, org-roamauctex, polymode, org-roam,sage-shell-mode,yasnippetmagit, treemacs, org-modeOrg, Auctex, magit, org-ref, org-roam, mu4e, straight, use-package, synosaurusorg, auctex, magit, ivy, company, flyspell-correct, ws-butler, elfeed, ess, el-patchlsp, projectile, ivy/ido, magit, emacsMagit, undo-tree, rusticprojectile, magit, counselOrg-mode, src-blocks, language modes, multiple-cursororg, magit, mu4e, helm, elfeed, nano, eglot, gtags, cscope, elpyorg-mode, org-roam, auctex, mu4e,Evil,org-modeemacs-lsp, magit, org-mode, tree-sitterxterm-mouse-mode,latex-preview-paneorg mode, gforth.elevil-mode, evil-collection, magit, lsp-mode, company, vertico, embarkmagit, eglot, org-mode, projectile, selectrum, consult, marginalia, embark, rgshell, dired, tramp, org, vertico, consult, embark, citarmagit, org-mode, lsp-mode, vertico, orderless, org-roam, mu4e, elfeed, consult, projectileorg,evil,general,use-packagego-mode, catppuccin-theme, haskell-mode, ocaml-modeMagit, eglotflycheck, lsp-mode, company, modus-themes, elpher, yasnippetmagit, org-mode, diredmagit, dirvish, dwim-shell-command, pdf-tools, vtermmagit, lsp-mode, flycheck, orghelm, citar, dired, companymagit, perspectives, org-modeorg-mode, magit, projectile, amx, ivy, helm, elfeed, emms, calfw, eshellorg, org-edna, org-roam, avy, ace-window, wgrep, magit, eglot, popperEXWM, telega.el, geisermagit, modus-themes, embark, consult, vterm, which-key, elfeed, eglot, use-package, straightorg, ivy, mu4e, elfeed, dired, eshellMagit, orgmode, mu4e, ivy/counsel, emmsnotmuch, memacs, ledger, org-mode, org-roam, org-transclusion, yasnippet, denote, ox-tufte, org-super-agendaEVIL, lsp-mode, ivy, multiple-cursors, expand-region, smartparens, companymagit, org-mode, lsp-modeorg, corfu, consult, vertico, magit, hydra, notmuch, lispyMagic, orgmode, roam, deftAUCTeX, magit, tree-sitter, undo-tree, which-keyevil, avy, which-keyOrg-Mode,  Evil, Evil Snip, Evil Goggles, Evil Nerd Commenter, Avy, Undo Fu, vterm, valign, sisorg-mode, auto-complete, undo-tree, graphviz-dot-mode, expand-region, rg, org-brainmagit, forge, org-mode,notmuch, evil, tramp, org-ql, treemacs, lsp, org-roamorg, mu4e, elfeed, eglotwhole-line-or-region, password-store, simple-mpc, git-timemachine, orgit, embark, exwm, avy, project, ace-windowmagit, org,Magit, Org Moderestclient, expand-region, slime, cider, visual-regexpOrg-mode, Vertico, Orderless, Marginalia, Corfu, org-roam, which-key, modus-themeshelm,projectile,popwin,swiper,expand-region,browse-kill-ring,undo-fuuse-package, ivy, monroe, ace-window, magit, vtermorg-mode, magit, org-superagenda, boon (modal editing mode), general.el, which-key, daft, mu4e, tempel, impatient-mode.Org-mode, denote, hydra, eglot, vertico, corfu, ledger-mode, evil, magit.avy,hydra,ivy,lspmagit,multiple-cursorsmagit,org-mode,tramporg-mode,magit,sly,lispy,eglot,tramp,vertico,pdf-toolsmagit, magit, magit, magit, magit, magit, magit, slime, quack, helmmagit, ido-mode,Magic, org, evilIvy, ivy-rich, helpful, which-keyOrg-roam, org-roam-ui, vterm, ledger, auctex, helm-bibtex, companyevil, pdf-toolsorg-mode, straight.el, org-qlslime, org-mode, elpy, custom 6502 and 6809 modesorg-mode,rust,rssmagit,orgMagit, evil-mode, deft, org-roam, lsp,Org-roam, magitmagit, eglot, erlang-mode, cedet, erc, org-mode org-babel ! (<3 org-babel) ,elang , paredit,ace-window, atomic-chrome, dired, eglot, elfeed, embark, iedit, magit, modus-themes, org-modemagit, projectile, docker, restclient, pass, browse-at-remoteOrg, Gnus, amx, crux, which-key, elfeed, exwm, typo, pdf-toolsorg-mode,haskell-mode,lsp-mode,company,selectrum,prescient,magitmagit, notmuch, lsp-mode, rusticorg, org-roam, magit, gdb, evileglot,corfu,vertico et. alkey-chord,hydra,yasnippet,tree-sitter,rainbow-delimiters,org-roam,transmission,circadian,helpful,which-keyevil,robe,lsp,snipeevil, dired+ranger, magit, LSP, DAP (but it hardly works), vterm, projectile, org, helm, workspacesmagit, auctex, reftex, lsp, which-key, idoOrg-mode, magit Plus too many more to listorg-mode, modalka, hydra, yasnippet, magitmagit, cider, projectile, org-modemagit, org-roam, auctexEvil,god-mode,org-roam,vertico,consult,embark,orderlesstreemacs,tldr,ein,ob-pythonI couldn't tell really. I view them as part of the emacs experience and do not really care about their names or specifics of they just stay out of the way.magit, evil, rjsx-mode, rainbow-delimiters,Magit, racket-modeMagit, treemacs, nix-modeThis is way too long of a list and I would be hard-pressed to pick favourites.lsp-mode, git-link, racerorg-mode, org-roam, magit, ivymagit, evil, eglot, org, tree-sitterorg, org-roam, elfeed, general, org-roam-bibtextramp, web-modemeow,vertigo,eglot,embarkCompany, lsp, Vertico, embark, web, beacon, smartparens, flycheck, ripgrep, popperElse, straight, org-mode, ivy, company, which-key, yasnipped, projectile, lsp, daporg-mode, org-drill, markdown-modeevil, sly, geiser. I don't use many packages, my config is tiny and I haven't bothered digging further in the direction of spacemacs (which is where I started iirc).magit hs-minor-mode autocompleteevil, which-key, vertico, straight.el, cider, sly, org, lispy, helpful, pdf-toolsorg, evil, web,org-mode, magit, pdf-tools, consulthelm, mu4e, bongo, magit, lsp-ui, org-modeivy, lsp-mode, mu4e, hydra, transient, org, magiteglot, modus-themes, rainbow-mode, rust-mode, slime, use-package, delight, js2-mode, magitmagit,org-mode,evil,symbol-overlay,consult,embark,corfu,verticoprojectile magit paredit clojure-mode cider clj-refactor cider lsp-mode orgexwm, magit, bongo, slime, modus-themesLsp-mode, emacs-dashboard, org-roam, org-modeOrg-roam, emacs-jupyter, org-roam-ui, Mu4e, Vertico, Consult, Marginalia, org-transcludemagit,dired-hacks,eglot,ef-themes,dwim-shell-command,hydra,rg.el, multiple-cursors, crux, orgvertico,corfu,magit,elfeedpolymode, yasnippet, undo-treeuse-package, selectrum, companyorg-roam, lsp-mode, magitAvy and evil-easymotion Helm Evil-surround and evil-embrace Org Magitlsp-mode,magit,auctex,helm-bibtex,vlf,ccls,neotree,frog-jump-buffer,projectileMagit, Tramp, org-mode, org-roam, helmmagit, neotree, vertico, elpymagit org-roamOrgmode, magit, lsp-mode, consult, verticoemacs-jedi, avy, auto-complete, flycheck, use-package, undo-tree, visual-regexp-steroids, dumb-jumporg, magit, straight, use-package, git-link, vertico, consultorg-mode, expand-region, eglotProjectile, ivy, dracula-theme, which-key,magit, denotewhich-key,magit,company,lsp,Org, Magit, lsp, flycheckmagit,org-mode,json-modeorg-mode, org-roam, evilorg,magit,evil,lsp-mode,treemacs,org-modern,tree-sitter,projectile,vertico,vtermconsult, embark, avy, magitMagit, org-mode, undo-tree, ciderorg-mode, mu4e, magit, exwm, vc.el, elfeed, emmsleaf.el, region-bindings-mode, expand-region, projectile, company, magit, ivy, yatex, yasnippet, twittering-modemagit, expand-region, wdired, wgrep, ryo-modal, helpfulmu4e, lsp-modeVertico, consult, elfeed, pdf-tools, osm, AUCTeX, cdlatex, orderless, Embarkmagit,org,verticomagit,snitch,scope-capture,dired,orgOrg-mode, magit, dired, evil, persp-mode, company/corfu, consult, vertico, lsp-mode/elgot.Setup.el, Straight, Magit, Smartparens, Vertico, Consult, Embark, Avy, suggest.eldashboard, expand-region, magit, multiple-cursors, paredit, rg, undo-tree.Org,org-roam,org-super-agenda,mu4e,verticoESS, org mode, evil mode, magitMagit, cider, org-mode,org-mode, magit, ivy, evil-mode, multiple-cursorsPython mode, json, macro defining, diredvertico, citre , magit, consult, embark, wgrep, cape, dumb-jumpboxquote, browse-kill-ring, company, magit, orgmode, fixmee, projectile, smartparens, nyan-modeElfeed,orgcider, clojure-mode, paredit, magit, counselerc, org, live-python-mode, org-roam, magitMagit, projectile, rg, lsp-modeOrg,org-roamVertico, marginalia, orderless, which-key, magit, pyvenv, eglot, use-packageorg-roam, evil, org-super-agenda, org-chef, essorgmode,helm,yasnippet,magit,elfeed,ess,modus-thememagit, evil, rustic, org-babelauctex, magit, proof-general, org-roamEsscider,magit,helm,lsp-mode,flycheck,smart-mode-line,multiple-cursors,swiper-helm,use-package,pareditCurrently only: key-chord, goto-last-changeuse-package, auctex, cider, eglot, elfeed, elpy, vertico, vterm, mu4e, org-modeMagit, circe,org-mode, lsp, dap, agenda, python mode (with poetry, pyenv), magitMagit. Vertigomagit, consul, projectile, mu4e,org-mode, ERCuse-package, eglot, magit, org-roam, which-key, minions, tree-sitter, auctex, org-caldavMagit, Org-mode, Org-roam, Eglot, Verticolsp-mode,magit,evil,general,which-key,vertico,orderless,marginaliamagit (et al), elgot, tramp, cc-mode (a true c-mode!) posframe (et-al), tempel, consult/vertico/corfu (combined)avy, ivy, counsel, swiper, magit, web-modeundo-tree, which-key, expand-region, smartparens, magit, vertico, consult, pacfiles-mode, hippie-exporg-mode org-roamMu4e, cider, avy, consult, company, lispy, popper, magitevil, eglot,Magit, Flyspell, dired, projectile, persp-mode, Ivy, counsel, deadgrepMagit, Projectile, OrgMagit, org-journal, projectileOrg-mode, Magit, Orderless, Vertico, Consult, Marginalia, Notmuch, Evil-mode.magit, projectile, elpy, multiple-cursors, expand-regionevil suitemu4e, eglot, magit, orgboon,magiteglot, magit, evil, sly, corfu, swiper, consultmagit,exwm,projectile,lsp-mode,org-mode,evil,ivyvterm, magit, eglotemmet-mode, eglot, sly, pass, circe, ivy, general, which-key, vterm-tmux, yasnippetmultiplecursors, org, acemagit,You care about new packages. I don't. I didn't want to answer the previous question because I've never found a new package that looks interesting. I want multi-decade predictability.org-mode, helm, plantuml, magit, visual-regexp, undo-treeauctex, pdf-tools, guess-languagemagit, ace-window, fuzzy-finder, rg, windresizevc,org,eglot,rust-mode,elfeedtelega,magit,vtermno-littering,helpful,magit,lsp-mode,ciderorg-mode,magit,auctex,helm,org-jira,lsp-mode,tramp,undo-tree,benchmark-init,use-packagemagit,org,evil,lsp-mode,projectilecompany, counsel, magit, smexCorfu,Consult,Magit,which-key,sr-speedbar,vertico,eglot,org-roam,multi-vtermevil, emacs-lsp, avy, projectileprojectile, flx-ido, ag, scala-mode, lsp-metalsflycheck TRAMP (built-in now) magit many language modesAnki-Editor, evil, mu4e, orgorg-mode, flycheck, magitorg-mode, geiser, treemacsmagit, org-mode, pdf-tools, ivyI am not aware of third-party packages as something that a "manager" exists for.verb,highlight-symbol,company,rainbow-delimiterswhich-key, lsp-mode, eglot, zoom, ivy, magit, multiple-cursororg-mode, helpful, ivy, minions, plantuml-mode, rg, slime, which-keyxah fly keysmagit, orgmode, verticoivy, polymode, magit, hydra, ess, counsel, auctexac-jump-mode, magit, org, projectile, web-modeembark, orderlessmagit, org-mode, ivy, counsel, lsp-mode, hydra, paredit, projectilecider, company, org, clojure-lsp, agenda-mode, magitRestclient, lsp-mode, orgmode, auctex, magitorg-mode, magit, eaf, hl-todo, corfu, companyorg-mode, Ramx, company, diminish, flycheck, projectile, rainbow-delimiters, rainbow-mode, swiper, undo-tree, yasnippetlsp-mode,magit,dirvishMagit, trampmagit, magit, magit, paredit, ido, clojure-mode, cider, projectileMagit, Cider, Counsel, Org Mode, Sayid, Avylsp, magit, elpher, elfeed, mu4edired, mu4e, org-mode, evilOrg, org-superagenda, zen mode, lsp/eglotOrg-roam, embark, Magit, elgotCider, paredit, elpy, dashboard,orgivy, helpful, whichkeyaquamacs auto-complete google-translate syslog-mode tabbar-ruler tree-mode aok bashdbido, smex, ag, avy, undo-treeorg-roam, avyMagit, helm, org, lsp, flycheck, pdf-tools, treemacs, vterm, tramp, undo-treemeow, use-packageorg-mode, lsp-mode, companyorg-mode, auctex, yiddish.el, various packages I wrote (mailaprop, yank-match, urlete)wanderlust, org-modeESS, org-roam, magitorg-roam,org,lspmagit,swiper,ciderorg-mode, magit, erc.Link-hint, avy, org, SLY, smartparensOrg-mode, Org-roam, Evil-mode, also-mode, whichkey, Vertico, Projectile, Doomemacs,apache-mode,dockerfile-mode,keychain-environment,backup-each-save,neotree,powerlinediredorg,magit,ace-jump-mode,cider,pareditcompany, diff-hl, eglot, rust-mode, rainbow-mode, web-mode, htmlize, pdf-tools, php-modemagit, ercorg-roam,lsp-mode,magit,hydra,consultmagit, evil, doom, org-roammagit,org-mode,auctex,modus-themesmagit, ivy, swiper, ace-window, multiple-cursorsmagit,avy,lsp-modefountain-mode, Olivetti, evilmagit, projectile, wgrep, lsp-mode, -modeobjed, magit, tempel, DAP, org-auto-tangleorg-mode, ergo, straightMagit, corfu, vundo, lsp-mode, tramp, diredorg-journal, zetteldeft, org-super-agendaMagit, org-mode, projectile, cider, combobulatehelm, magit, companyMagit, tideidlwavelsp-mode (I'll have to eglot a try now), doom-themes, a lot of the "base" ones with Spacemacs, evil, company, helmmagit, ryo-modal, helm, mu4e, emms, org, zenburn, vterm, which-key, direddashboard, rustic-mode,Magit, consult, vertico, corfu, mu4eivy, dired++, emmet, magit, undo-tree, use-package, visual-regexp, web-mode, which-key, yasnippetmagit, ivy, golden-ratio, evil, roamorg-mode, elpy, magitprojectile,crux,multiple-cursor,drag-stuff,string-inflectionlsp magitsmartparens, magit, evilmagit,org-mode,rustic,helm,undo-tree,smartparenslsp-mode, company, helmcompany,irony,jediOrg-mode, Haskell-mode, vertico, orderless, lspOrg Mode, Denote, Use-packageorg-mode lsp* packagesuse-package,centered-window,wgrep,dashboard,pdf-tools,mu4eorg-roam,vulpea,evil,org-fragtog,org-appeaeCIDER, modus-vivendiGNUS, ORGorg, magit, eshell, gnus, tuareg, exwm, flycheck, iedit, perspective, proof-generalcounsel, dired, magit, web-mode, counsel-fd, git-linkMagit, Org, firestartertramp, magit, lsp-mode, kubel, paredit, elpy, go-dlveglot,evil,org-modern,vertico,consult,org-ql,empvuse-package, vertico, orderless, marginalia, eglot, which-keyorg-*, magit, lsp-server, filetree, diredTRAMP, magit, vterm, julia-snail, eglot, org-mode, org-roam, pdf-tools, ivyhelm, use-package, projectile, org, magitmagit, org-mode, rest-clientprojectile, magit, vtermmagit,cider,smartparensdebian-el,dpkg-dev-el,gnus,flymake-shellcheck,sudo-edit,elphermagit, org, forge, elfeedMagic, projectile, lsp-mode, tramp, diredorg-mode, avy, swiper, Ido, which-keymagit, org-mode (ecosystem), python, diredeglot, magit, evil, swiper, projectileorg-mode,which-key,use-package,ivy,eglotorg-mode, magit, paredit, tramp, elscreenMagit, org-mode, vertico, lispy, parensdoom-modeline,auto-completeWeb-mode, diredflycheck, magit, haskell-modemagit, smartparens, eglot, treesitter, vtermexec-path-from-shell, yasnippet, try, which-key, ace-window, consult, projectile, vterm, lsp-mode, magitundo-tree, calc, custom unpublished packagesPython, pyvenv, eglot, magit, evilorg-mode,evil,mu4e,undo-treeEvil mode, straight, use package, magit, orgDired magit lsp org mu4e projectilestraight,vertico,consult,corfu,cape,magit,orderless,eglot,marginalia,keycastOrg-mode, magit, vertico, eglotOrgmode,magitmagit, company, yasnippet, mu4e, orgprojectile, magit, lsp-haskell, org-mode, diary, dired, git-timemachine, helm, pdf-tools, ef-themesorg-mode, calc-mode, magit-mode, org-edna, elfeed, elfeed-tube, mpv-mode, mpdel/libmpdel, flyspell-mode, nov.eleglot, apheleia, flymake, verbI believe I do not use any packagesmagit, lsp-mode, diredCIDER, Paredit, ProjectileMagit,transient,meow,org-roam,verticoOrg mode, Magit, mu4eorg, elfeed, magit, mur4eeglot, avy, evil, f, envrc, s, htmagit, org-roam, evil, slyevil, org, ivy, lspmu4e,pdf-tools,yasnippet,CEDET,auto-complete,ggtags,mic-paren,projectile,rmsbolt,srefactorprojectile,company,flycheck,use-packagemagit,use-package,projectile,vertico,orderless,marginalia,embarkdeadgrep,lsp-mode,undo-tree,use-package,magit,which-key,exec-path-from-shell,helmMagit, evil, eglotmagit, use-package, flycheck, vertico, consult, org-modeIvy, Smartparens, dired, yassnippet, companyevil, lsp-mode, which-key, ivyMagit, docker, kubelmagit, forge, telega, ef-themes, vterm, eglot, meow, dirvish, ementstraight, ctrlf, iedit, smartparens, browse-kill-ring, dirvish, nov, visual-regexp, corfu, hide-linesEvil, Org, Magit, Tramp, Helm, Projectile, undo-tree, SLIME, mu4e.org, org-roam, magit, marginalia, consult, orderless, dirvish, esupDap-modeEvil, which-key, companylsp-mode, rustic, Haskell, justlVertico, use-package, org, lsp-mode, slyOrg, magit, slime, geiserMagit,sorry, there are too manyelpy Orgdimmer,dired,polymode,goto-addr,helpful,ivy,key-combo,markdown-mode,theme-looper,Org-mode, w3m,magit,cidercc-modetreemacs, lsporg, org-modern, org-roam, git-gutter, ddskk, volatile-highlightsmagit, eglot, project, vertico, restclientorgmode,which-key,vertico,consult,marginalia,org-roam,magit,mu4e,easy-hugo,pdf-toolsorg, org-babel, magit, evilorg-mode, smart-mode-line, solarized-theme, speedbarmagit,vterm,evil,consult,rg,org,projectile,so-long,roam,better-jumpermagit, vertico, consult, org-mode, paredit, cider (clojure), lsp-modeorg-mode, org-roam,auctex,ivyauctex,evil,cmdlist.el,ivy/counsel/swiper,org-mode,org-roam,magitorg-mode, various language modesmagit,embark,vertico,lsp-mode,projectileemms,magit,orgmeow, vertico, magit, consultivy, bind-key, ace-window, magit, slime, swiper, yasnippet, flycheckmu4e, magit, auctex, org-modeevil, ivy, lsp-modeThe built-ins.magit,telega,orgorg-mode, magit, org-roam, lsp, transient, dash.el, frog-jump-bufferorg-mode, lsp-mode, helm, magit, swiper,ivy,sly,paredit,eglot,multiple-cursors,ripgrepMagit, dired, org-roam, deft/not-deft, hydra, ivy, counsel, swipervterm, telega.elorg-mode,magit,avy,expand-region,projectitle,company,vertico,lsp-modewhich-key,yasnippet,evil,magit,projectilemagic, rust-mode, rustic-mode, use-package, planner-modeparedit, mu4e, proof-general, better-defaults, auctexcider,treemacs,doom-themesMagit,Yasnippet,use-packageace-window, winner, counsel, swiper, company, yasnippet, writeroom-mode, org-brain, magitevil-mode, corfu, eglot, dashboard, valignmagit, frontmacs-javascript, tidetetris, treemacs, auto-completeMagit, marginalia, denotemagit, multiple-cursorsorg-mode,dashboardorg-noterProjectile, helm, better-defaults, org, paradox, lsp, blacken,Magit, org-mode, Helm, lsp-mode, cider, expand-region, which-keymagit, org, ivyevil, company, lsp-mode, vterm, magitAUCTeX, Org-mode, Org-roam, dired, equake, calfw, org-superagenda, mu4e, org-noter, zotxtelfeed,rainbow-delimiters,geiser,beacon,companyMagit , org-mode , SEMANTICevil,org,org-super-agenda,org-ql,magit,consult,embark,eglot,tree-sitterlsp-mode, rustic, eglot, vertico, treemacs, evil, hl-todo, magit, dired, company-modetreesitter,flycheck,evilOrg-mode, god-mode, lsp-mode, magithelp-fns,magit,undo-tree,evil,ivy,which-keyorg, evil, magit, straight, which-key, projectile, ace-window, vtermorg, magit, ciderdefault-text-scale, inf-ruby, flycheck,magit,org,projectile,verticoConsult, selectrum, org-roamOrg, notmuch, auctex, magit, org-transclusion, ebib, proof-general, direnv, geisersmartparens, org-mode, ox-twbs, ementcider, helm, use-package, trampemmet,org,helm,avy,olivettiorgmode, projectile, org-drill, cdlatex, deadgrep, expand-region, hydra, org-roam, pabbrev, yasnippetmagit, ef-themes, modus-theme, beancount-mode, eglot, org-roam, avy, flycheck, flymake, easy-hugomagit, projectile, org mode, treemacs, lsp, go-mode, rustic/rust-analyzerorg-mode, projectile, magit, lsp, verticotypescript-modecounsel,ivy,magit,projectile,evil,avy,iedit,lsp-modeelfeed, read-aloud, magit, org-modeorg-mode, org-roam,CIDER, docker-tramp, dumb-jump, magit, elpher, idle-highlight, multiple-cursors, nov.elrustic,web-mode,projectile,web-django-mode, nxmlInf-clojure, clojure-mode, use-package, ido-everywhere, multiple-cursors, org-modeiedit, cider, sly, orderless, magit,avyThere are just too many.ace-jump-mode,ace-window,key-chordcperl-mode, polymode, mhtml-mode, tide, typescript-modeProjectile Helm Org Magit lsp-mode flycheckevil, magit, org,org, magit, lsp, mu4e, telega ...magit, deft, pareditorg-roam,org, coterm, bash-completion, magitOrg, magit, mu4e, fired, calcmultiple-cursors, ivy, avy, expand-region, emmet-mode, helpful, swiper, company, pdf-tools, ace-windowcounsel, ivy, company, yasnippet, which-key, eglot, auctex, sly, rgxah-fly-keys,vertico,consult,magitmagit, evil, consult, vertigo, wgrep, projectilemagit, evil, org, multiple-cursors, python, cpp, lsp, daporg, magit, eglot, flycheck, consult, helpful, direnv, notmuch, elfeedeglot, org, paredit, hungry-deletemagit, eglot, ivygod-mode, use-package, evil, lispyvilleorg-mode, gnus, emms, eglot, ivy, modus-themes, magit, vtermorg, counsel, evil, general, magit, projectileOrg mode, paredit, clang-format, erc, magitagressive-indent, treemacs, multi-vterm, yasnippetmagit, helm, company, treemacs, yasnippet, expand-region, clang-format, eglotorg-roam,lsp,mixed-fontorg-mode,magit,tramp,helm,dired,regexp-builder,elispmu4e, elfeed, org-super-agenda, lspeglot, magit, key-chord, helpful, which-keyOrg-latex-previewfavourites: -org-mode (new) -gnus hate: -auctex (written in a convoluted way; wish something else existed) -mmm-mode (it doesn't work; successors are too complicated to setup...)magit, org-roam, auctex, pdf-tools, vertico, elfeed, notmuchorg,avy,mu4e,lsp,consult,vertico,magit,embarkw3m, pdf-tools, elfeed, geiser, nov, slimelsp-bridge meow.el telega.elHelm, Magit, RGB, LSP-modeOrg, LSP, Cidermagit, ein, org, eglottreemacs, lsp, pomodoro.el, org-modecider,magit,evilevil, evil-collections, projectile, corfu, vertico, lsp-mode, which-key, consult, doom-modelineorg-mode,defttidal,elpher,orgmode, org-roamorg-mode,magit,telega,lsp-mode,projectile,ivy,fb2-readermagit, expand-regionTreemacs, eglot, lsporg-mode, ivy, counsel, tramp, vterm, lsp-mode, auctex, emacs-jupyter, diredparedit, magit, sly, cider, verticovundo, affe, verb, aphleia, corfu, vertico, tree-sitter, magit-forge, emacs-lsporg, magit, perspective-mode, Tideace-isearch, org-mode, magit, cider, perspective, avy, ace-window, helpfulmagit elfeed ivymagit, org-mode, tramp, web-mode, visual-regexp-steroids, lsp-modePackage defaultsorg-mode, vertico, which-key, ido-modeevil, undo-tree, orgmode, yasnippet, neotree, writeroom-modeorg, pdf-tools, magit, evil, elfeed, notmuch, verticoevil-mode, lsp-mode, emacs-vdiff, dap-mode, treemacs, which-key, ivy, vtermorg-roam,org-roam-ui,company,orderless,selectrum,org-download,dracula-theme,calfw,rainbow-modeparedit, rainbow-delimiter, rainbow-identifier, rusticevil, lsp, magit, helmmagit, org-mode, org-roam, dumb-jump, helm, logview-modemagit, lsp-mode, magit, org-mode, magitmagit, org, lsp, restclientmodus-themes, org, org-roam, ligature, dashboard, lsp-mode, auctex, centaur-tabsmagit, cider, selectrum, straight, ctrl-fmagit,evil,suggest,lsp-mode,verticoevil-mode, magit, org-mode, consult, vterm, lsp-mode, popper, verticoMeow, telega, dired+, gnus, hyperboleelfeed, org-mode, lsp-mode, consult, vertico, corfu, helpful, mu4e, pdf-toolsHelmmagit, which-key, forge, tree-sitter, evil, lsp-modemagit, org-mode, diff-hl, ido-mode, projectile, company, lsp-mode, tree-sitterorg, magit, forge, helm, org-ref, org-ql, elfeed, eglotvertico, consult, corfu, marginalia, magit, undo-fu, tree-sitter, which-key, yasnippet, desktop+magit, cider, apheleia, paredit, vtermevil, treemacs, vtermeglot,pulsar,diff-hl,which-key,restclient,expand-mode,exec-path-from-shell,eglot, modus-themes, magit, expand region, tree sitter, embark, vertico, consultmagit, lsp, orgOrgmode,projectile,cider,parensOrgmode, ivy, elfeedevil-mode,evil-collection,ido,helm,flycheckmagit, helm, multiple-cursors, company, flycheck, lsp-mode, selected, treemacs, bufler, nswbufflsp-bridge,lispy,pareditmagit, flycheck, web-mode, zenburn-themeeyebrowse, company-*, git-link, helm, jedi, magit, projectilevundo,undo-fu-session,recomplete,spell-fu,mode-line-idle,bookmark-in-projectmeow,vertico,corfu,orderless,prescient,pdf-tools,vc,dired,shellorg-journal, magit, lsp-mode, evil-multiedit, writeroom-mode, org-roam, org-pomodoro, emacs-easy-hugoemacs-which-key,visual-fill-column,mct,org-roamESS, org-mode, org-roam, citar, pdf-tools, elpy, evil, dirvish, persp-mode, good-scrollorg-gtasks, LSP, org-pomodoro, deft, company, projectilemagit, gnus, org-mode, trampmagit, vterm, org-mode, lsp-mode, treemacsselectrum, orderless, marginalia, eglot, multiple-cursors, magitOrg, Org-roam, Helm, modus-themes, magit, use-package, org-cliplink, mpv.el, EINace-windoworg-mode, server, python-mode, ess, magit, tramp,Auctex, Cdlatex, yasnippets, helm.org,org-super-agenda,tramp,consult,embark,avy,rfc-mode,devdocs,magit,lsp-modemagit treemacs centaur org-mode gopcaml-modeelpher, eshell, eww, flyspell, gnus, org-babel, org-brain, trampcounsel, ivy, org-modeace-jump-mode, ace-window, eglotEXWM,Magit,mu4e,vterm,ledger-mode,dired-hacks,Evil,god-mode,general,alect-themesPrelude.el,Magit,Rustic,lsp-mode,Org-mode, Org-roam, org-journal, Magit, CIDER, Eviltreemacs, org-modeMagit, Tuareg, multiple-cursors-mode, HelmEglot, use-package, vundo, magit, modus-themes.I'm new to Emacs - started using it in earnest earlier this month. I have intentionally not installed any packages. I wish to learn Emacs first.magit, vertico, marginalia, helpful, elfeed, org, shackle, eglot, telega, zoomSLIME, Org Mode, treemacs, move-text,magit,org,tuareg,tidal,Magit,consult,embark,corfuavy, counsel, flx, magit, multiple-cursors, restclient, slime, swiper, vterm, wanderlustorg,pandocmagit, org-mode, evil, straightprojectile, magit, org-mode, avyOrg, Magit, evil, helpful, elisp-demos, macrostep.el, vertico, eshellmagit, lsp, evil, org-modemagit,projectile,avyeshell, notmuch mail, mail mode (?) for sending mail ctrl-x m, tramp, magit, dired, c-mode, cperl-mode, lua-mode,org, calccounsel, mu4e, elfeed, org mode, evil, ledger, pocket readerexwm,lsp-mode,vterm,ivyorgmode,magit,emms,gnusCIDER, org-roam, vterm, which-key, evil, smartparens, lsp-mode, magit, projectilemagit, eglot, vertico, org-mode, ebdb, auctex, pdf-tools, notmuchLsp, rest client, rustic, ciderMargit, eglot, cidervisual-fill-column,org-mode,org-revealuse-package, slimeorg-mode, org-roam, citar, org-babelmagit, lsp-mode, tree-sitter, vertico, auctexorg-mode,lsp,Magit, use-package, notmuchorg-mode, merlin,auctexmagit, orgmode, vertico, evil-multiedit, dired, vterm, pdf-toolsorg-mode, org-roam, yasnippetProjectile, LSP-mode, company, helm, flycheck, magitorg paren uniquify kc-smartinput ethan-wspaceorg-mode, org-super-agenda, helmLsp, ivynotmuch, ivy, flycheck, multiple-cursorsMultiple-cursors, magit, SLY, SLIME, geiser, org-modeMargit, use-package, org, LSP, vterm, trampVertico, orderless, reverse-immagit, subed, consult, denote, lsp-mode, docker-mode, trampMagit, org mode, lsp-modesmex, ido, lsp, eglotmagit, evil, org, mu4eorg-mode, eglot, vertico, tree-sitter, jupyter, magit, consult, marginaliaMagit, lsp-mode, vtermHelm, lsp-modeorg-modern and eglot (not a package anymore in master)desktop, themes, fly*, emacs-serverorg, deftCode-cells,tramporg-mode, magit, org-roam, prescient, expand-region, modus-themesorg, org-roam, deftorg, evil, magit, lsp-mode, tree-sitter, eglot, pdf-tools, auctex, cdlatex, org-roamOrg, magit, multiple-cursors, orderless, eglot, persp, projectile, undo-tree, expand-regionrainbow-delimeters, ess, multi-cursors (mc?)eglot, anything by protEmacs packages? I don't use any, OS packages? I will look up how to add an OS package repo and then install packages from that repo.org-mode, tree-sitter, emmet-mode,evil,color-rg,wgrep,org-mode,tab-bar,lsp-bridge,Org-mode, magit, projectile, perspective, evil, vertico, corfuorg-mode, mu4e, org-contacts, iflipb, olivetti, typo, synonyms, org-superstar, calfwmagit, smartparens,magit, org-roam, selectrum, vertico, marginalia, evil, general.elMagit, org-mode, org-roam, verticoMagit, eglot, mu4e, orgorg-mode,org-roam,straight,magit,lsp-mode,ace-window,all-the-icons,elpherediff c++-mode swift-mode, java-mode, python-mode, shell-script-mode, html-mode docker-mode recentf git-commandOrg-mode, Magit, Dired, Corfu, Tree-sittervertico, consult, embark, marginalia, ciderrustic,lsp-mode,leo-language,crux,mu4e,vertico,magitorg-mode,ess,auctekmagit,vtermMagit, sql-mode, cider, j-modeorg-mode, merlin, tuareg, ocp-indent, ocamlformat, magit, company-modemagit, eglot, vertico, orderless, corfuDoom-modeline, ef-themes, all-the-icons, lsp,org,pdf-tools,zenburn-theme,undo-tree,avy,helm,swiper-helm,helm-bibtex,spell-fuMagit,org-roam,evil,smart-compile,Vertico,doom-modeline,emms,org-capture,trampevil, eglot, org-modecitar, auto-activating-snippets, LaTeX-auto-activating-snippets, consult, pdf-toolsOrg-mode org-roamelfeed, transmission, magit, dired, doom-modeline, setup, multiple-cursors, expand-region, yasnippet, org-ednalsp-mode, org-mode, helmorg-mode, plantuml-mode, pandoc, presentation, lsp-mode, lsp-ui,Helm, shell, iedit, magit, occur, rgreporg-roam,vtermevil, yascroll, visual-regexp-steroids, company, org, org-roam, ebib, doom-modeline, postmagit, avy-modesly, org-roamtramp, org, proof-general, ace-jump-modemagit,org-mode,projectile,iedit,tide,helm,easy-kill,embraceMagit tramp helmOrg-mode, org-roam, lsp-mode, AUCTexorg-mode, treemacs, magit, counsel, selectrum, consult, marginaliaEvil, Org, Dired, Helpful, Which-Key, Ivy, SwiperEXWM,vterm,magit,CIDER,ace-window,lispy,avy,lsp-mode,org-modemagit, mu4e, org-roamMagit, engine-mode, elfeed, mu4e, orgOrg-mode, Org-web-tools, ox-hugo, ivy, avy, helm, swiperevil,org-mode,vertico,company,lsp-modeslime, geiser, orgmode, diredorg-mode, magiceglot,magic,flycheck, company, cider,slymagit, python-pytest, cider, ido, smex, ag, mpuzorgmode, lsp, org-babelmagit,org,evilmultiple-cursors, corfu, vertico, embark, herculesVTerm, org-super-agenda, wgrep, Corfu, Vertico, Marginalia, Embark, Sly, Magit, Pareditmeow, pass, elfeed, org-mode, org-agenda, eww, ebib, denotemagit,counsel,org-mode,eglotOrg-mode Verticoorg,ledger,shellvc, project, eshell, TRAMP, infomagit, eglot, lspThe whole Vertico/marginalia/consult stack, denote, corfu, citar, org, magit, project (with my Tabspaces package), mu4eevil, magic, lsp-mode, org-modeahkmode, applescript-mode, auctex, idostraight,evil,org,jupyter,ement,mu4e,general,paper-themeauctex,flyspell,color-theme-modern,ido-modeuse-package, magit, yasnippet, multiple-cursors, restclient, tidemagit, magit-forge, lsp-mode, company, org-mode, projectile, verticomodern-cpp-font-lock, whitespaceorg,no-littering,company,magit,literate-calc-mode,ox-reveal,org-roam,org-roam-uimagit, cider, restclient, orgmagit,org,avy,consult,vertico,embark,marginalia,ef-themesMagit, projectile, org-mode, org-roam.flyspell, org-mode, magit, auctex, all the packages that make ssh work on linux, post-mode, writeroom, helm,sly, magit, org-modeMagit, Trampivy/counsel, magit, nov (epub reader), org, org-web-tools,Org Mode (duh), Magit (duh), EXWM, Selectrum, Marginalia, Modus themes, Eglot, Denote, Corfu and all its cousins,Magit, evil-mode, mu4e, zen-mode, org-mode, go-modeevil,magit,mu4e,company,org,org-roam,tramp,lsp-modelsp,embark,multiple-cursors,pdf-tools,doom-themes,which-key,all-the-icons,kind-iconmagit, ivy, evilEglot, Treemacs, Agda2-mode, dashboard, tramp,straight.evil, doomorg-mode, org-roam, diredProjectile, Ivy, Expand-Region, Multiple-CursorsClojure-mode, Cider, Dired, iBuffer, vimgolfmagit,org,org-roamwhich-key, helm, magit, org-mode, auctexpretty-hydra, vertico, modus-themes, lispy, treemacs, racket-mode, highlight-indent-guides, aggresive-indent, deadgrep, mini-framewhich-key,magit,hydra,easy-kill,undo-tree,org(/roam),lispy(really like the navigation on this one)org, magit, vertico/consult/etc.tide, magit, org-roamsly -- the common lisp IDE Proof General -- the proof assistant interface dashboard -- looks goodorg, org-roam, dired, embark, vertico, avy, magit, consult, orderless, marginaliaciteproc,gnuplot,ob-blockdiag,ob-ipython,openwith,org,org-drill,org-roam,org-roam-bibtex,ox-ipynborg-mode, olivetti, flyspell, use-package, dashboard, doom-themes, mood-line, company, elpher, tramporg-mode,org-roam,magit,evil,multiple-cursors,lspDenote, ivy, org, recentf, speedbar, highlight-indentation,expand-regionSly, Slime, Evil, Organzu, auto-sudoedit, auto-rename-tag, Ido, projectile, magit, undo-tree, vterm, eglotmagit, eglot,org-mode, magit, consult, vertico, embark, eglot, org-roam, vtermJedi,yaml-mode,prettier-js,flycheck,apheleia,company,company-tabnine,centaur-tabsMagit, helm, consult, vertico, bash completion, eglotdoom-modeline,org-ref,helm,smartparens,laasmagit,eglot,consultorgmode, notmuch, eterm, vterm, lspMagit,Org,Lsp-mode,Boon,Company,Vertico,Marginalia,Embark,Consultuse-package, magitDon't know what a package is but this question is mandatory so I checked all the answers. This applies to any subsequent mandatory question that I have no opinion about.pdf-tools, undo-tree, eglot, ledger-mode, magit, ivy-pass, emms, elfeed, bbdb, auctexmagit, eglot, format-all, evilmultiple cursors, org, Smexmagit, elpy, pyenv-modeI know about org-modebut don't use itSupersave, keyfreq, blamer, lispy, cidermagit, vterm, org-modeorg, magit, mu4e, vundodired, magit, org mode, hyperbole, meow, borg, notmuch, vertico, nov, pdf-toolstreemacs,blacken-mode,eglot,flymake,org,magitorg-roam, adaptive-wrap, visual-fill-column, magit, projectile, perspective, tideleaf, corfu, consult, orderless, fussy, lsp-mode, verticoevil, org-mode, org-roam, lsp-modeevil,org-mode,lsp-mode,eglot,company,ivy,vertico,projectile,magitmagit, cedet, tramp, org-modeMagit, eglot, corfu, vertico, marginalia, embark, consult, iedit, Org, vundoNot surecompany and related, irony and related, ivy, swiperorg-mode, org-roam, dired, notmuch, counsel, exwm, counsel-rg, org-ql, org-agenda, org-attachLast, org, magitmagit,hydra,cider,eglot,dasherc, web-mode, companynyan-cat, lsp, dimmer, neotree, multiple-cursors, yasnippet, projectile, org-super-agendamagit, slime, company, flycheckcalc, org-mode, proof-general, tramp, haskell-modeMagit, evil, org, eglot.multiple-cursors,mu4e,helm,swoop,projectile,magit,ace-window,ace-jump-modemagit, company, ctrlf, dired, flycheck, helm, helpful, lsp-mode, org, slyIvy,Agressive-indent,paredit,crux,magit,expand-region,multiple-cursorsAUCTeX, Org, Wanderlust, Olivetti, diredflevil,magit,org,ivy,avy,eglot,auctex,pdftools,notmuch,lispymagit, dired, edit-server, dired-rsync, lsp, org-modemagit,org-mode,ivy,avy,flycheck,counsel,company,key-chord,swiper,yasnippetorg, magit, geiser-mode, eglot, highlight-parenthesesivy, magit, org-modeorg-mode, olivetti, expand-region, org-appearboon, selectrum, elfeed-orgOrg-roam, evil, magit, treemacs, ess, lsp, beaconMagit, evilcider,mu4e,corfu,org-mode, magit, helm, companymodus-themes, vertico, eglot, org-fragtog, emms, magit, pdf-toolsGo-modeorgmode,cider,helpful,magicNotmuch, ercorg-roam, easy-hugoorg-appear, org-modern, org-ql, org-pandoc, visual-regexp,lsp*,auctexivy, ivy-rich, slyorg-roam, lsp-bridgeorg-mode, mu4e, evil, vterm, consult, project-tab-groups, embark, magit, vertico, envrcEglot,AucTeX, evil, general, magitorg-mode, yasnippet, move-stuff, rust-mode, platformio-mode, condaMagit, exec-path-from-shell, YASnippet, use-packageMagit, org-mode, vterm, pdf-tools, lsp-mode/dap-modeivy, helpful, treemacs, vterm, tree-sitter, lspOrderless, consult, embark, magit, Emacs-nsh, org-mode, lsp-mode, eglot, treesitter,magit,ag,wgrep,multiple-cursors,key-chord,multi-vtermeditorconfig,flycheck,plantuml-mode,slime,gemini-modeorg, gnus, bbdb, auctex, pdf-tools, ess, sql, tablist, csv-mode, erc.magit, lsp-mode, tree-sitter, flycheck, rime, company, projectile, use-packageIvy, ace window, LSP, companymagit, ag, org-mode, multiple-cursors, projectile, ido, lsp-mode, aggressive-indent, git-auto-commit-modemagit, mu4e, dired, telega, elfeed, which-key, evil, lsp, corfuDenote, consult, embark, eglot, julia-snailevil, math-preview, drag-stuff, base16-thememagit, eglot, use-package, corfuxclip, proxy-modeIvy, Magit, Org, PlantUML, smartparens, multiple-cursors, xcscopevertigo,magit,org,haskell-modeorg-mode,consul,embark,undo-treedenote, eglot/lspmeow, verticomagit, flycheck, lsp-mode, go-mode, projectileOrg, evil, ivy, which-keyevil, f, company, avy, lsp-mode, rainbow-delimiters, pos-tip, session-asyncEvil, magit, spaceline, cdlatexOrgmode, magit, markerpenprojectile, eglot, org-mode, org-roamAUCTex, Elfeedprojectile, lsp, paredit, helmmagit, helm, orgMagit, tide, ciderparedit, vertico, consult, embark, denotecider, slime, use-package, verticoorg-mode,org-roam,lsp-mode,rusticMagit, Modus themes, Vertico, Elfeed, PDF-toolsuse-package,dracula-theme,evil,undo-treeswiper, magit, eglot, smex, which-keymagit, evil, projectile, cidermagit, helm, auctex, irony, elpyivy,lsp-mode,company-mode,org,treemacs,darkroom,magit,agda-mode,geiser,nano-emacs,org,org-d20,volatile-highlightsProjectile, magit, treesitter-sly, paredit, magit, org-mode, visual-regexporg-mode, org-mode-roamslime, editorconfig, inform-mode, restclient, web-modeeglot , lsp-mode,TeXhydra, magit, eglotlsp-grammarly,elfeed, nord-theme, I mainly use the built-ins and little third-party packages.Company, eglot, helm, use-package, vlf, ws-butlerevil,sly,gnus,eshellorg, clojure-mode, clojure-lsp, magitcrux, diminish, direnv, exec-path-from-shell, hungry-delete, multiple-cursors, phi-search, web-mode, which-key, winumevil,treemacs,which-keyswitch-window, yasnippet, org-bulletscompany, deadgrep, dtrt-indent, flycheck, helm, lsp,projectile, org-mode, lsp-mode, magit, helm, evil-modeorg-super-links, ctrlf, helm-org-rifle, logos, org-appear, unfill, visible-mark, wrap-region, avy, ediffmodus-themes,org,org-modern,mu4e,vertico,consult,embark,tramp,doom-modelineivy,magit,exwmevil,magit,lsp-mode,yasnippet,undo-treeCIDER, clojure-modemeow,emacs-rime,dirvish,org-roam-ui,eaf-broswer,lsp-bridgeorg, evil, magit, yasnippetorg, magit, expand-region, yasnippet, ace-jump, ido, howm, todo-modeevil, popper, powerlineorg-mode, evil-mode, TRAMP, org-roam, flycheck, lispyville, lsp-mode, straight, companyMagit, org, mu4e, elpy, treemacs, dired, tramp (could be easier)corfu,vertico,eglotOrg-mode ayctex cperl-modedenote, org-mode, magit, git-gutterlsp, ace, company-complete, magit, helmevil, evil-org, evil-collection, org-roam, ox-pandoc, org-superstar, mixed-pitch, writeroom-mode, elfeed, verticoleaf.el, straight.el org-mode, org-roam, org-roam-ui, elfeed, consult, diirvish, magit, evil-modemagit,org-mode,counsel,ivySly, Julia Snail,magit,magit-forgeevil, awesome-tray, cape, corfu, vertico, consult, tempelSlime, Eglot, treesitterphp-mode,lsp-mode,yasnippets,helm,company-mode,flycheck,magitmagit, lsp-mode, treemacs, org-mode, calc, eshell, vterm, evil, trampevil,magit,which-key,projectile,company,ibuffer,undo-treeorg-mode,org-roam,helm,elfeed,pdf-tools,mu4e,yasnippet,magit,bookmark+,helm, magit, lsp-modeIvy, magitevil-mode, org-mode, lsp-modeeglot, project.el, icomplete (fido), modus-themes, wgrep, rg.el, ediff, web-mode, flyspellOrg mode, nov.el, projectile, magitorg roam, lsp server julia, aas, laas, helm-bibtex, org ref, org roam bibtex, latex, cdlatexevil,evil-collection,dired,project.el,deadgrep,consult,magit,lsp,orgmagit,org,lsp-mode,flycheck,company,helm,projectile,vterm,deadgrep,undo-treeHelm,comment-dwim,use-package,eglotevil,ivy,lsp-modeauctex, centaur-tabs, dired-sidebar, markdown-mode, nyan-mode, spacemacs-theme, yaml-modecc-mode, orgevil, magit, lsp-mode, projectilemagit,notmuch,eglot,smex,ido,winner,window-purpose,project,tramp,orghelm, org-mode, lsp-emacsorg-mode, ESSsmartparens-mode,tree-sitter,magit,which-keyevil,org-mode,geiser,org-kanbanMagic, lsp, slyauctex, sly,magit, mu4e, paredit, pdf-tools, which-keymagit,ace-jump,diminish,flycheck,smex,cperl-mode,js2-mode,paradox,undo-tree,yasnippetevil-mode, org-mode, magitmagit, git-timemachine, smartparens, nhexl-mode, flycheck, lsp-mode, reformatterOrg, magitOrg-mode, magit, eshell, lsp-modeevil, org, ibuffer, general, magit, lispy, smartparens, cider, geiser, elpherOrg mode, ledger, elpyprojectile auto-complete ggtags flx-ido deferred mic-paren typopunct ac-python-asyncmagit, vterm, which-keymagit, paredit, gnus, mastodon, eshellmagit, flycheckmagit, reverso-context, counsel, eshell, eglotmagit vterm (terminals in a terminal ;) org-mode ivy, though ido works really well alreadymagit, dired, lsp-mode, helmmagit, jupyter, orgmagit, proof-generalorg, mu4e, org-msg, pdf-tools, org-rifle, org-super-agenda, helmlsp-mode/elgot, magit, restclient, org-mode, dired, calc, tramp for ssh, slime, anaconda-modespacemacs, magit i am also pretty excited that the external language server support has landed. hopefully we can integrate live-share with vs code someday soonstraight, org-mode (and friends), org-roam, projectile, lsp-mode, plantuml-modeevil, magit, org-roam, lsp-mode, dap-mode, slyorg,magit,consult,marginalia,orderless,vterm,tramp,gnus,dired,elfeedvertico,consult,org-mode,org-roam,eglot,flyspell,dired,tramp,haskell-mode,project.eleww,org,mu4eOrg mode, auctex, mu4e, diredhelm, smartparens, company, projectileuse-package, rjsxmagit, eglot, trampEvil, Ivy, use-package, which-key, org, general, dired-single, undo-tree, vterm, yasnippetmagit, eglot, hydra, forgeorg,lsp-mode,magit,flycheckmagit, org, projectile, helmorg-roam, org-roam-bibtex, org-noter, org-pdftoolsAuctex, proof-generalMagit, Org-modeorg-mode, ivy, notmuch,auctex,elfeed,org-roam,magit,company,ggtags,yasnippetorg,mu4e,proof-generalmagit, helm, hydra, perspectiveOrgmode, magittramp, org, polymode, ess, ffap, dabbrev, sql, org-refEvil, Doom modeline, Doom themes, LSPmagit,org-mode,projectile (although I switched to project.el now),lsp-mode,multiple-cursors,expand-region,undo-treeMagit,vertico,rangerhelm,powerline,company,flycheck,org,flyspell,ruby-mode,python-modeorg, org-roam, org-roam-ui, org-roam-bibtex, org-noter, org-agendaOrg mode Evil Zettledeft Deft Rgrep Essmagit,company,org-*,evil,flycheck,helm,hydra,projectile,use-packagemagit, straight, embark, vertico, eglotorg, ivy, swiper, which-key, calc, dired, evil, magit, eshell, helpfulPulsar.el, minimap, org-re-reveal, centaur tabs, org-modernmagit, org-fragtogmagit idoevil, org-mode, company-mode, org-roam,elcordcompile, ivy, emacs-libvterm, notmuchmagit,git-link,git-timemachine,cider,eglot,project.elforth-modeExwm,magit, calcevil, org, airline-themes, dirvish, vertico, marginalia, consult, general.el, paredit, eshellmagit,helm,ess,company,lsp-modeevil, magit, circe, mu, projectile, counsel/ivy, vterm, lsp-modeOrg-mode, Markdown-mode, Dracula-themeMagit, Projectile, Rest Client.Evil, Notmuch, Swiper, Magit, Merlin, OCamlFormat, Markdown-mode, Modus-themesivy,projectile,magit,eglot,tide,slimeorg-mode, magit, use-package, ivylsp-mode, evil, magitLsp, sly, multiple-cursors,helm,helm-agleaf.el,lsp-modeMagit,org-mode,lsp-mode,go-mode,rainbow-delimiters,diff-hl,etermvertico, ccls-mode, avy, lsp-mode, kaolin-themes, magit, evillspmode, vertico, Consult, embarkdirvish, org-roam, evilmagit, swiper, wgrep, expand-region, treemacs, lsp-mode, nyan, iedit, multiple-cursors, corfulsp-mode, notmuch, diredmagit, modus-themes, evil, eglot, notmuch, undo-tree, orgmagit, lsp, projectile,auto-package-update, vertico, consult, highlight-symbol, key-seq, dired, tree-sitterCider and magit. mu4e is also awesomeOrg-mode Evil-mode Tramporg-mode, org-roam and zen-modemagit, eglot, which-key, vundo, iflipb, yasnippet, rainbow-identifiersEvil, Magit, undo-tree, hotfuzz, devdocs, rmsboltOrg-mode, org-roam, AUCTeX, elfeed, mastodon.el, simple-mpc, Geiser, Eshell, vtermproject, magit, eglot, flymake, xref, diff-hl, csv-mode, vc, dired, modus-themesHelm, helm-agCIDER,jdecomp,magit,separedit,vtermstraight, leaf, meow, bongo, citar, denote, consult, avy, ace-window, flycheckdired, org, multiple-cursors.org-mode, modus-themes, org-ref, magit, marginalia, corfu, orderless, lsp-mode, tree-sitter, vtermMagit, Deft, Org-Mode, Beacon, Notmuchlsp-mode, rustic, org, evil, magitOrg, Magit, Lexic, Vertico, Embark, Marginalia, Citar, doom-modeline, vtermvertico, corfu, consult, embark, citar, mu4e, crdt.el, lsp-mode, magit, org-roamevil,helm,company,projectile,sly,which-key,mu4e,notmuch,org-roam,magitprojectile, magit, lsp-mode, orguse-package, vertico, marginalia, consult, auctex, reftex, cdlatexIdo, Dired, TRAMP, Keyboard Macros, Org-Mode/Org-Agenda, Magit, AUCTex, PDF Tools, Notmuch, Org-Roamevil,evil-collection,lsp,magitorg-mode, dired, helm, yasnippet, helm-git-grepProjectile, Magit, org-mode, evil modeDeft, elfeed, tramp, org, eglottree-sitter,orgmode,magitmagit,evil,evil-collection,vertico,lsp-mode,CIDER,slyMagit, counselmodalka,bookmark,goto-chgorg-mode, org-roam, org-roam-ui, modus-themes, evil, org-super-agenda, org-ql, citar, olivetti, nov.elhelm,org,slyOrg, smartparens, helm, visual-regexp, dired, ediff, flycheck, lsp, multiple-cursors, restclientwhich-key, ivy, notmuch, elfeed, magit, paredit, ws-butleruse-package,elpy,evil,magit,erlangvertico, consult, org, marginaliaorg, org-roam, which-key, ESS, julia-snailmagit, lsp-mode, flycheckflycheck, magit, pandoc, cider/clojure, package(!!), org(!!)lsp-mode org-mode mu4e magit evil verticoEglot Counsel Swiper Projectile MarginaliaOrg, swiper, dired, magit, helpful, multiple-cursors, pulsar, yasnippet, plantumlmu4e, evil-mode, evil-collections, org-mode, magit, lsp-mode, dap-modeAucTeX,org-mode,Company, flycheck, ESS, irony, Magitmagit, tree-sitter,magit, use-package, eglot, tree-sitter, modus-themeswindow-purpose,expand-region,cdlatex,lsp-mode,notmuch,org-ref,org-roam,pdf-tools,elpy,pyvenvxah-fly-keys,elfeedmagit, outshinemagit,org,helm,vterm,tree-sitter,direnvvertico,corfu,evil,magit,texmacsorg-mode, notmuchmagit, orgmode, mu4e, slimeHelm, treemacs, lsp, company,undo-tree, rcircMagit, git-timemachine, symex, rigpa, racket-mode, evil, evil-collection, sunrise-commander, hydra, dictionaryEvil, lap-mode, projectile, rusticdoom-modeline, symbol-overlay, vertico, consultevil, magit, helpful, eglot, mu4e, vertico, telephone-linemagit, rtags, elfeedprescient, embark, org-babel, magit, forge, vertico, capemarkdown-mode, ligature.el, mmm-mode, apache-mode, develock, rainbow-identifiers.el, yaml, post.elMagit, diredmagit, evil, rmsbolt, scroll-on-jumpmagit,org-mode,evil-modevertico,consult,lsp-modeyasnippet, vterm, ivy-rich, lsp-modelsp-mode,magit,blamer-modeOrgmode, whichkey,vertico, org-roam, ldeger-modeEvil, magit, orgmagit, command-log-mode, org-modeexwm, magitivy, cider, lsp-mode, vertico, orderless, consultorg, yasnipets, magitorg, doommixed-pitch,synosaurusMagit, lsp-mode, Helm, projectile, companyMagit, org, org-roam, embark, eglot, elfeed, mu4e, vtermdired, markdown-mode, flycheck, multiple-cursor, web-mode, typescript-mode, emmet-modehighlight-symbol, change-inner, keyfreq, string-inflection, helm-tramp, company, elpy, magit, projectile, ryo-modalblacken,pandoc,rust-mode,auctexmagit, org, dired, projectilepareditEvil, CIDER, Sly, eyebrowse, lsp-mode, orderless, marginalia, vertico, corfu.Lispy, Avy, Cider, Magitevil, org, magit, auctex, company, which-key, smartparens, lsp-mode, flycheck, echo-bellorg-roam ; org-transclusion ; org-mode ; org-babelorg,which-key,evil,all-the-icons,doom-modeline,lsp-bridgelsp-mode, helm-rgmagit, projectile, treemacs, helm and it's plethora of integrations with everything, eglotorg-roam, evilorg, nov, auctexOrg-mode, helm, org-roam, auctex, rust-modemagit, lsp, ruby-mode, smex, terraform-mode, yasnippitAgda-modeuse-package, rainbow-delimiters,vterm,pdf-tools,magit,projectile,ivy,counsel,which-keymagit, ivy, counsel, solarized-theme, elfeed,I never discover a new package that looks interestingMagit, envrc, multiple-cursors, eglot, Corfu, vertigo, embark, consultVertico,Corfu,Cape,Orderless,Helpful,paredit,slime,ledger-mode,calibredb,denoteMagit, helm, avy, lsp, yasnippet, company, org, ispell, undo-treeHelm, yasnippet, org-mode, hydraorg-mode, rust-mode, cargo-mode, tuareg-mode, whitespace, auctexmagit, org, flycheck, ncl-mode, ace-jump, smexmagit, org-mode, bbdbdoom-themes, lsporg-mode,magit,notmuch,mu4eOrg,Magit,Mu4eace-window,corfu,god-mode,vundo,zoomMultiple cursors and idoavy,ivy,wich-keys,org,org-roam,ef-themes,counselMagit, ivyorg-roam, pdftoolsmagit,consult,company-boxmagit,org,hydra,yasnippet,lspemacs-jupyter, yasnippet, org-mode, browse-kill-ring, speed-type, multiple-cursors, mc-extras, ace-mc, org-ref, atomic-chromeEglot, idle-org-agenda, memento-mori, diminish, color-identifiers-mode, hamburger-menu, highlight-parentheses, pdf-tools, org-notermagit, org-mode, org-roam, lsp-mode,Org-mode,magit, org-mode, helm, evil-mode, projectile, mu4eESS, magit, vertico, prescient, dired, package.el,magit, eglot, projectile, mu4eEshell, AUCTeX, undo-tree, Helm, EWW, pdf-tools, Dired, Flyspell, Mingusorg, helm, magit, wgrep, eglot, tramp, multiple-cursors, company, org-ref, pdf-toolsemacs-orderless,emacs-consult,emacs-embark,emacs-marginalia,emacs-prescient,emacs-corfu...Magit, org-mode, god-modeorg-mode, org-roam, helm, magit, yasnippetsMagit, Orgmode, atomic chromemagit, evil-mode, projectile, helm, org-modeivy-rich, ess, elfeed-tube, move-text, multiple-cursors, which-key, rainbow-delimiters, vundo, corfu, minimapSLIME, nyan-mode, company, evilorg-modern, EIN,org-mode, helm, chronos, tiny, so manyevil, magit, lsp-modeMultiple cursors,undo tree,hydra,org,org roam,gcalcompany, which-key there are more but i am not on my pc so i dont rememberorg,org-roam,vertico,hotfuzz,magit,eglot,elfeedVertici, orderless, embark, marginalia, magit, lsp-mode, flycheck,vdiff, vdiff-magit, helpful, markdown-modeeglot,lsp-mode,projectile,meson-mode,company,yasnippetorg-mode, mu4e, org-roam, magitorg, auctex, embark, eww, orderless, mu4eevil, org, org-pomodoro, lsp, avy-jumporg-mode, themes (ef, modus, kaolin), eglot, elfeedorg-roam, modus themes, vertico.elmagit, monkey, which-key, ivy, counsel, direnv, flyspell, lsp-mode (even if a bit slow sometimes), diredelpher,org-roam,ivy,better-defaults,magituse-package, AUCTeX, rainbow-delimiters, lsp-mode, magitorgmode, ESS, org-cite, org-refmagit, evil, dirvishorg org-roamOrg,magit,lsp-modecalc, org, magit, avy, key-chord, hydra, multiple-cursorsorg, magit, boon, csv-mode, acme-theme, xah-fly-keysorg-mode, ada-mode, Tuareg, Merlin, flyspell, ansi-color, magitmagit, projectile, org, flymake, zone, workspacesSlime, counsel, ivywhich-key, AUCTeXcirce, org-mode, maggit, evil-mode, ruby-modeuse-package, evil, magit, lsp-mode, projectile, yasnippetConsult, vertico and the likes Magitmagit, projectile, helm, lsp, flycheck, cider, treemacsOrg-superstar, Org-roam, Elfeed-summary, Empv, Meownov, projectile, magit, vterm, tramp, docker, org, emmsslime,cdlatexmagit, org, trampmagit,zop-to-char,ein,lsp-mode,which-key,hydra,ivy,deadgrep,wgrep,projectileNot if I want to do something else with my day :-)magit, lsporg-roam, org-roam-ui, org-transclusion, org-remark, emacs-citarlsp; helm; ace; magit; companyevil, flycheck, company, lsp-mode, magit, ivyorg-roam, org-modeOrg-mode, org-roam, elfeed.org,lspMarkdownlsp-pythonmagit, org-mode, eglot, company-mode, multiple-cursors, ace-window, buffer-move, markdown-modegnus, erc, org-mode, magit, paredit, org-mru-clock, literate-calc-modeorg-mode, evil, company, gnushydra, treemacs, racket-mode, gnusMagit,telega,org-kanbannov.el, emms, mu4erjsx-mode, elpy, markdown-mode, magit, rust-mode, visual-regexp-steroidsEvil, Embark, Selectrum, EXWMvertico, corfu, cape, puni, tempel, php-mode, php-runtimeedebug,orgmodeEvil. Ivy. Orgorg-mode, mu4e, magit, eglotMagit, org, eglot, verticoorg,vertico,prescient,embark,consult,citarorg, magit, eglot, company-modeMagit, Org-mode, Vterm, Lsp-modemagit, org-roam, mu4e, consult, embark, verticomultiple-cursors, company-php, magit, flycheck, php-mode, flyspell, restclient, web-mode, string-inflection, symbol-overlayace-window,anzu,deadgrep,dired-subtree,elscreen,emacs-w3m,highlight-indent-guides,restclient,topspace,vtermorg-mode, pdf-tools, essparedit-mode, slimemagit, ivy, git-messenger, projectile,highlight-symbol-mode,multiple-cursor-mode,visual-bookmarks,phi-grep,tramp,slimemagit,org,projectileMagit, Org-Mode, EglotMagit,ciderCIDER, haskell-mode, lsp-mode (wanting to try eglot as well), org-mode (and all its extensions)cider, slime, company, flycheck, forgetting 10s of otherseglot,org-roam,avy,lispy,cider,meow,expand-region,consult,verticomagit, vc, cc-mode, ediff, lots of Prot's stuff, some orgmultiple cursors, magit, expand region, hungry delete, swiper/ivy, projectile.Notmuchelfeed, lsp-mode, smartparens, counsel/ivy, treemacs, projectile, yasnippet, magitMagit,org-roam,rgorg-mode, org-babel, magitMagit, perspectives, projectile, helmSly, gnus, erc, corfu, avy, magit, smartparens, orderlessconsult,lsp-bridge,orderlessorg-mode, consult, vertico, denote, which-key, marginalia, ieditmagit, vundoexwm, eglot, vertico, corfu, consult, cape, orderless, eat, magit, copilotmagit, evil, helm, lsp-mode, org-modemodus-themes, magit, terraform-mode, company, pinentry- org-mode - magit - auctex - cdlatex - lsporg, magit, decipher-mode, lsb-mode, evil, generalMagit mu4e lap-mode org flycheckmagit, lsp-mode, dired-xmagit,sly,geiser,mu4e,evil-mode,lsp-mode,lispy,flycheck,writegood-mode,Circe,Magit,guess-language,vterm,org,org-caldavorg-mode, magit, cider, exwmOrg magit any trampmagit,lsp-mode,ace-window,rusticparedit, slimemagit,org,deft,paredit,eglotDeadgrep, lsp-mode, erlang-modemagit, paredit, cider, eglotsimple things like: project.el, embark, straight.el and so on. Way to many good onesorg, magit, consult, dired-hacks, expand-region, git-gutter, lispy, lsp-mode, try, yankpadmu4e, org-mode, archive-region, magit, symon, calfw, ispell, fountain-mode, ledger-modemagit, vertico (et. al.), elfeed, mu4e, evil (et. al.), lsp-mode, org-mode, org-roam, ace-window, treemacslsp-mode,projectile,vtermbetter-defaults,eglot,elpherswiper, projectile, persp-mode, rg, fzf, fd, magitmagit,org,mew,slime,elpy,vterm,ercLots of file-type specific modes (markdown, json, swift, lua, objc, ruby...), dumb-jump, svg, mingus (mpd)...gnus, notmuch, flymake, eglotmu4e, company-modeOrg-mode, Magit, Eglot, Paredit, Modus themes.org-babel, nyan-mode, rainbow-mode, whichkeyhelm, magit, smartparens, symbol-overlay, undo-tree, winumorg-mode,org-drill,elfeed,org-roam,org-journalMagit, org, notmuch, geiserMagit, evil, eglot, vertico, projectmagit, eglot, projectile, crux, tree-sitter, combobulate, vterm, yasnippet, ido, ido-vertical-modemagit, org-mode, helmeglot, use-package, fido-vertical, company, auctex, unfill, ebib, multiple-cursors, abc-modesymbol-overlay,vertico,orderless,consult,csv-mode,org,openwith,evil,olivetti,emacs-everywhereCider, org-mode, org-roammagic, vertico, evil, auto-activating-snippets, pareditvertico,orderless,ef-themes,denotelsp-mode,helm,tree-sitter,org-roameglot,org-mode,try,sly,vceww,emacs-maildir,deft,howmdenote, company, vertico, pdf-toolssly, companycider, magit, olivetti,org,org-roammeow, lispy, sly, orgmagit,cider,org,trampevil, auctex, elpy, company, auto-complete, etcavy, org-roammagit, corfu, vertico, consult, lsp-mode, evilsmart-dash-mode, lsp-mode, ivy/counsel, yasnippetslime, lspgood-scroll, ivy, counsel, swiper, avy, flycheck, which-key, expand-regionhungry-delete,magit,treemacs,yasnippetOrg, org-roam, golden-ratio, docker-tramp, magit,org mode, ecb, compileevil-mode, monroe, notmuch, org-mode, trampuse-package, crux, org, ido, magit, expand-region, projectile, yasnippet, company, lspGud, slime, dlv, and rmail magit and rectangular editing (is that a paackage?) org mode for notes, talks via webex, and documentation/essaysMagit, org-mode, org-roam, cider, projectile, dired, vtermmagit, ace-window, evil, bug-hunter, general, avy, vterm, org,ESS, fido-vertical-mode, windmove, desktop, tab bar, dired+, multiple-cursors, AucTeX, company mode, org-modeCalc,eglot,vertico,consult,avy,a modules based thing for interacting with some internal systems at my employer,smartparensverilog-mode, ivyWgrep, lsp mode, dap mode, expand region, magitmagit, helm, visual-fill-column, evil, expand-region, poly-mode, company, elpy, elfeedmagit,org-mode,visual-regexp,web-mode,company-mode,magit, org, lsp, elglotVertico, marginalia, orderless, embark, auctex, org-roam, org-tree-slideorg, mu4e, magit, slimenotmuch, org-modeConsult, Ef-themes, Marginalia, Modus-themes, Vundo, Which-keymagit, org-mode, consult, flyspelleglot, straightmagit, treemacs, helm, lsp-mode, imenu, projectileESSuse-package, magit, rust-mode, lsp-modemulti-line, vhdl-modemagit, cider, orglsp-mode, org-roamMagit, denote, lsp, ledger, ace-jumpgeiser, verilog-mode, companyorg-mode, lsp-mode, scimaxEXWM,general,doom-themes,magit,org-modern,lsp-modeorg-mode, minimap, beacon, treeview, auto-complete, neotree, auto-complete-clangorg-roam, treesitter, yequakeracket parenthesis modeauctex, telega.el, gnus, emms, ein, bbdb, essmagit, multiple-cursors, + many other built in packagesorg-mode, nyan-mode, tramp-modeorg-roam, lsp-uievil-mode,magit,envrc, eglot,use-package,straightexwm,lsp-mode,org-jiraMagit, ess, hl-todo, TRAMP, org-modemagit, helm, org modelsp-mode, company, flycheck, go-mode, markdown-modeorg-mode, ef-themes, which-keyno-littering, general, dumb-jump, paredit, which-key, flymake, eglotorg-mode, mu4e, org-ql, org-super-linksmagit, eglot, project.el, orghelm,pdf-tools,nov,magit,projectile,multiple-cursorsorg-ml,pcre2el,named-timer,olivetti,flyspell-correct-avy-menu,evil-embraceorg, ox-reveal, use-package, eglot, doom-modeline, elfeed, mu4evertico, consult, embark, org-mode, auctex, eglotMagit, lsp-mode, ivy, swiper, org-modeEvil, org-mode, lsp-modeOrg, magit, lsp, write-roomcompany, verticoemacs-lspyes, yes(1)cider, magit, hydra, company, orgDired, embarkOrg,mu4e,which-keys,ivy,counselevil, use-package, consult (et al.), orglsp-mode, org, olivetti, smex, company, sly/slimeorg, gnuplot, uuid, slimeorg,swiper,company,dired+,tree-sitter,treemacs,no-littering,flycheck,zoom-window,too-long-lines-modeConsult, Vertico, Affe, dmacrocider,magit,rg,plantuml-mode,olivettiexwm, evil-mode, org-mode, eglothelm, magit, ebrowse, globaldoom, magit, org-roamediff, elpy, ivy, lsp-*, magit, org, pyvenv, rg, tramp, tree-sitterpinyin inputcompany, evil, projectile, ivy, auctexslime, eglot, material-theme-oceanmagit, evil, vertico, consult, lsp-mode, projectilemagit, orderless, org-roam, slime, geisermagit,cider,vertico,consult,org-mode,denotenov.el, evil-everywhereOrg-roam, Org, Evil, LSPorg, olivetti-mode, elpyaggressive-indent, declutter, elfeed, elfeed-tube, wallabag, literate-calc-mode, link-hint, olivetti, nov.el, telegaDeft, scroll-on-jumpMeow, multiple-cursors, yasnippet, eglot, projectile, consult, orderless.Orgmode, denotemagit,helm,company,counsel,powerlineMagit, Vterm, Multi-Vterm, Doom modeline, Cidermagit,amded,link-hint,notmuch,envrc,pdf-tools,pueue,rx-widget,tree-sitter,wgreporg, emacs-calfw, elfeed, magit, helm, lsp, mu4e, restclient, treemacs, twittermagit, ivy, counsel, swiper, doom-modeline,org-mode, ef-themes, ivy, avy, try, doom-modeline, all-the-icons, which-key, citeprocorg,magit,helmOrg,company,slyslime, magit, erc, gnus, expand-region, multiple-cursors, web-mode, emacs-w3m, mingusmagit,ejira,lsp-modelsp-mode, clojure-mode, slime, markdown-modemagit, eglot, mu4e, projectile, vertico, companymagit, org-mode, org-roamdirvish,lsp-mode,org-modeLsp-mode, evil-modemagit, evil, evil-surround, lspCIDER, magit, vertico, consult, mu4e, org-mode, orderless, corfu, perspective, smartparensorg-roam,evil,ivy,org-imagineDired, eshell, verticoUse-package Multi curser Ace jump IdoOrg-mode, Org-roam, pdf-toolsorg, org-caldav, vertico, projectile, lsp-mode, magit, emacs-slack, elfeed, notmuch, pdf-toolsmagit, org, avy, hydra, ...Magit, p4, ethan-whitespacemultiple-cursors,evil-nerd-commenter,vertico,orderless,good-scroll,whitespace4rmeow, prettify-symbols,magit, org, elfeed, cider, sweeprologOrg-mode, Olivetti, Avy, Elfeed, EWWElpher, Elfeed, EMMS, Dired, vterm, nov-el, mastodon.el, ox-epub, ox-gemini, orgmodeMagic, companyESS, mu4e, orgIvyvc, direkt, orgMagit, evil mode, web mode, good scroll, neotreeorg-mode, helm, cypher-modetramp tramp tramp x 1,000 rinari for rails but i should probably update/replace it. magit i'd like to get into org mode but don't really feel it/grok itorg-mode,magit,evil-modeOrg, Eglot, Pdf-Toolsmagit, orgit, sql-indent, org, org-babelorgmode,helm,magit,gnus,tramp,projectilemagit, org, projectile, lsp-mode, all-the-icons, flycheck, popper, vertico, orderless, embarkevil, vertico, org-based packaged, magit, writeroomMagit, Evil, Which-key, Projectile, CIDERavy,EXWM,magit,org,helm,telegawhitespace-mode, fill-column-indicatorelfeed, mu4e, org-static-blog, rainbow-modemagit, projectile, consult, prodigy, rgmagit, company, org-mode, undo-tree, ido, smartparensOrgmode, magit, eglot, vertico, corfu, consult, notmuch, gnusolivetti, helm, real-auto-save, which-key, adaptive-wrap, pulsar, denotemagit,org-mode,eglot,projectileOrg, Magit, Notmuch, Vertico, Orderless, Marginaliaorg,calfw-org,vertico,embark,consult,orderless,marginalia,which-key,dired-subtree,use-packagemagit, org, vertico, eviluse-package,projectile,magit,lsp-mode,ace-jump-mode,helm,tide-mode,companyorg-mode, xterm-color, trampOrg-mode,lsp-mode,magitorg, helmivygeneral, vertico, marginalia, corfu, cape, bufferlo, consult, org-modern, org-roam, org-roam-uirealgud-lldb, slime, helm, irony, cmake-mode, company, auctex,ac-math, ggtags, lsp-modeorg,markdownSwiper,counsel,ivy,doom-themesorg, org-roam, magit, org-agenda, which-key, helmDenote, pdf-tools, magit, vertico, orderlies, deft, ef-themes, orgHelm, WhichKey, Beacon, LSPexpand-region, ace-window, aggressive-indent, apheleia, avy, deadgrep, envrc, lispy, undo-fu-sessionelfeed, magit, lspMeow, lsp, lsp-ui, DAP-mode, no-littering, unicpde-fonts, perspective, vertico, orderless, marginalialsp-mode,vertico,corfu,org-mode,org-roam,magit,dap-mode,tree-sitter,yansippetlsp-mode,vterm,magit,tramp,ace-windowcmake-mode,company-rtags,json-mode,rust-mode,flycheck,markdown-modemagit, vertico, orderless, cider, slime, sly, vterm, pdf-toolsevil, org, which-key, ivy, lsp-mode, no-littering, prescient, all-the-icons, vdiff, generalmagit, doom-modeline, which-key, CIDER, expand-region, ace-jump-mode, smartparens, markdown-modehelm, magit, projectile, eglotProjectile, web-modemagit,slime/sly,raku-mode,use-package,csv-mode,auctex,lsp-modemagit, slime, gotham-theme, org-mode, command-log-mode, pareditgit-link, magit, use-package,org-mode, auctex, eglotMagit, Org-mode, Aphelia, Atomic Chromelsp-mode, magit, dired, org-modemultiple-cursors,expand-region,projectile-rails,Magit, Org Mode (love - hate relation) + Babel (only love), Denotemagit, multiple-cursors, smartparens, vterm, hydra, eglot, restclient, direnvorg-mode, cider, evil, magit, mu4emagit, forge, lsp, projectile, persp, tree-sitter, org-journal, key-chord-mode, smudgeMagit, transient, evil, lsp-modelsp,slime,glsl-mode,ag,projectile,jst-mode,dtrt-indent,powershell.el,nix-mode,web-modecider, paredit, magit, org-modeorg-mode, vertico, magit, ranger, org-roam, org-roam-ui, modus-themesevil, magit, eglot, haskell-mode, psc-ide, cider, projectile, ivy, swiperMagit, company, shelisptreemacs, lsp-mode, dap-mode, treesittercider, org-mode, vterm, magit, lspwriteroom-mode, elfeed, selectrum, swiper, SLY, haskell-mode, paredit, multiple-cursorsconsult, corfu, magit, eglotmagit,password-generator,pcsv,pdf-tools,request,slime,zoom,zygosporemagit, undo-fuOrg-super-agenda Citar Org-roamMagit, vertico, marginalia, cidercorfu, exwm, modus-themes, org, org-msg, sly, which-keyorg, magit, zoom, dired-subtreexah-fly-keys, eglot, verticomagit, org-mode, elfeed, org-roam, vertico, lsp-mode, rusticdarkroom, Org, EMMS, circadian, geiserorg-mode,evilmagit, deadgrep, vertico, consultlsp-mode, direnv, flyspell-modeCorfu,Vertico,Eglot,Envrc,Consult,evil,magitOrg-roam, mu4e, which-key, lsp-modeorg-mode, evil-more, gnus-mode, paredit, anzu, magit, trampconsult, vertico, embark, perspective.el, paredit, CIDER, deadgrep, xref, magit, smergemagit,ivy-counselorg, magit, ivy, eglot, writeroomMagit, Projectile, Avy, Ivyyasnippet, vertico, avy, dired-open, dired-rainbow, multistate, company, company-statisticsMagit, projectilemagit, consult, vtermcalfw, elfeed, elpher, magit, ob-restclient, projectile, treemacs, twitter, yasnippet, ztreeorg-roam,magit,cider,the one that shows a mini-buffer when you M-x in doomemacs with description and shortcuts (tried using emacs w/o doom and could not replicate it), nov.el,elfeed,evilprojectile, evil, use-package, orgevil, dired-single, rainbow-delimiteres,org, denote, spookfox, sly, eglotace, cider, eglotbeacon, fuzzy, git-gutter-fringe, htmlize, ido-yes-or-no, ido-vertical-mode, magit, restclient, simple-httpd, smexorg-mode. Various language modes, flycheck.org, magit, neotree, dad-joke, mpages, diary, calendar, tramporg-mode, ox-babel, ox-revealOrg, org-roam, hydra, org-ql, spotify.el, anki-editor, org-noter, ox-hugo, evilauctex,elpy,projectilecolor-identifiers-modemagit, dired, clojure-lsp, lsp, cider (Clojure)slime, company, paredit, prescientryo-modal, lsp-mode, doom-modeline, avy, vertico, consult, affe, hydra, magit, yasnippetiedit, lsp-mode, rust-mode, undo-treecider, use-package, dumb-jump, multi-curors, magit, org-mode, pareditcorfu, flycheck, lsp-mode, evil, consult,eglot, lsp-mode, undo-tree, magit, org-mode, org-roamOrg, tramp, magit, evil, lsp-mode, eglotoutshine, lsp-mode, tree-sitter, vertico, consult, orderless, evil, general, hyda, straightOrg mode, ESS, helm, company, dired, magitwhich-keymagit,projectile,verticoorg-roam,treemacs,magit,eglot,doom-modelinemagit, orgmode, *-lsphelm,lsp-mode,flycheckmagit, evil, lsp, swiper, ivy, projectile, counsel, doom-themesevil-mode,evil-surround,rainbow-mode,magit,git-gutter,yasnippet,rainbow-delimiters,peep-dired,dired-subtreeMagit, todoist, jiraevil-mode, magit, project.el, envrc-mode, org-modeLsp, Magit, mu4e, evil, verticoMagit, ef-themes, notmuchselectrum, prescient, company, sly,, org, paredit, magit, ef-themes, dtrt-indentHelm, ivy, multiple-cursors, Org-mode, projectile, mu4eyascroll, Helm, racket-mode, org-mode, buffer-move, paredit, rainbow-delimitersmagit, org-mode, elpyOrg-roam, org-roam-ui, latex-preview-paneorg-roam, eglot, magitmagit, ivy, org, swiperorg, cider, paredit, magit, treemacs, rg, find-file-in-projectMagit, lsp-mode, mu4e, company, projectiledeft, eterm-256color, vterm, avy, ivy,Org-Mode, Gnus, Cider, Web Mode, Puni, Companylsp-mode,which-key,evil-modeorg-mode, magit, vertico, consult, marginalia, corfu, projectilezone-matrixprojectile, cider, evilmagit ESS elpy calfw org-brainmagit, evil-mode, org-mode, verticomagit,company,eglot,dashboard,rainbow-delimitersmagit,elfeed,orgwhich-key,avy,tramp,helm,magit,slime,evilevil, magit, whichkeyeglot.elexpand-region, iedit, dumb-jump, rainbow-delimiters, olivetti, consult, undo-treeeglot, ledger-mode, magit, org-modeuse-package, magit, eglot, corfuevil,magit,hydravertico,orderless,eglot,vundo,orgIvy, Elpy, Ace-window, Beaconsmart-mode-line, multiple-cursors, recentfIt's all org. Org-mode, org-capture, org-agenda, org-roam (although I am going back and forth on the last one).Consult, vertico, dired, mu4e, ess, elfeedOrg,Magit,transient,Gnus,Eglot,Modus,which-key,page-break-linesmagit,nov.elorg-fragtog, inertial-scroll, doom-themes, doom-modeline, wc-mode, org-variable-pitch, typo-mode, pdf-tools, olivettiLsp, tree-sitterconsult, AUCTEX, org-mode, org-citar, eglotorg, ctrlf, vertico, vterm, rainbow-delimiters, magitorg-mode, org-roam, dirvish, flyspellelfeed, mu4e, corfu, verticonotmuch, org mode, magitauctex,lsp,org-mode,mu4e,citar,org-roam,vertico,which-key,evil-mode,vtermorg-mode, yasnippet, icomplete, consult, bookmark, vc, composable, helpful, multiple-cursors, which-keyorg-mode, org-babel, osx-hugomagit, org, lspmode, helmOrg mode, slime, magit, helmOrg, Magit, Ivy, elfeed, notmuchmagit, connsel, orgmodeMagit, org-mode, evil, projectile, swipertoo many…use-package, ox-hugo, magitconsult, corfu, magit, org, tab-bar, modus-themes, mu4e, elfeedorg;org-roammagit,mu4e,org,vertico,elfeedkubel,magit,helmorg-mode,emacs-lsporg, ws-butler, magit, undo-treemeow (currently in the process of switching to it), org-mode, dired, magitCIDER, magitgeiser, evil, vterm and rusticplan9port,vim,pacmanelpy, tideOrg-mode, lsp-mode, helm, projectileconsult, orderless, vertico, minions, hippie-completing-read, filldent, avy, macrostepbrowse-kill-ring, deadgrep, flycheck, unfill, magit, ido-completing-read+, rust-mode, ace-window, lsp-mode, which-keyevil, org-mode, org-roam, magit, yasnipet, lsp, ztree, kubernetes, tramp, vtermorg-mode, org-web-download, anki-editorOrg, Magit, Notmuch, Ivy+Swiper, pdf-tools, ESSorg-mode,slimeOrg, magit, eglot, evilEvil, Ivy, magit, org-mode, pdf-tools, transient, image-roll, doc-toc, iedit, epcmodus-themes, denote, vertico, consult, orderless, tab-bar-mode, expand-region, org-mode, embarkorg-mode, lsp, gdscript-mode, company, vertico, too many to tell :Pevil, mu4e, ebibmultiple-cursorsdired,magit,vterm,marginalia,modus-themes,mu4e,orderless,org-roam,vertico,vtermorg, auctex, helm, gitlab, tramphelm, org-mode, helm-ag, lsp-modemagit, org-mode, projectilestraight.el,use-package,evil,magitess, ace-window, auctex, elpyOrg, most built-ins, Evil, Magit, LSP (love/hate)use-package, meow, avy, recentf, icomplete-vertical, prettify-symbols-mode, telephone-line, org-mode, cdlatex, magitProjectile, magit, ripgrep, eglotmagit,org-mode,slime,cider,projectileorg-static-blogmagit, lsp-ui, orgmagit,lsp-mode,web-mode,org-mode,helm,helm-projectile,projectilemagit, org-mode, wanderlust, lsp-mode, omnisharp, ruby-mode, latex-modeconsult,posframe,perspective,avy,vertico,dirvish,lsp,dap,flycheck,embarkmagit, org, org-roam, merlincompany-mode, flycheck, helm, magit, mu4e, org-mode, php-mode, phpactor, yasnippeteglot,projectile,embark,paredit,sly,zenburn-themeMagit, ef-themes, vertico, transientmarginalia, which-key, ibuffer, all-the-icons, elfeed, paredit, rg, magitmagit, org, interleave, ivy, proof-general, pdf-tools, avydeadgrep, org-mode, vterm, avy, s, f, tablist, lsp-mode, lsp-ui, rusticvertico,corfu,orderless,eglot,project.elorg-mode,org-journal,hydra,ivy,counsellsp-mode,evilmagit,rg,flycheck,auto-complete,jedi,web-mode,org-roam2, org-mode, bibtex, eww, org-babel, hledger-mode, elfeed, pandoc, org-capturehyperbole, vertico, orderless, elfeed, haskell-mode, geisercounsel,ivy,evil,pdf-toolsmagit, eshell, org-mode, elpherorg-ref, org-roamorg,hydra,web-mode,lsp,windmove,leetcode,pdf-tools,pyvenv,projectile,cdlatexmagit, slime, rcirc-color, projectile, 0x0, elfeedivy, ivy-rich, counsel, avy, helpful, elisp-demos, sly, org-roam, use-package, expand-regionorg, consult, marginalia, vertico, lsporg-mode, ox-ipynb, solarized-theme, avy, ace-window,magit, tramp, docker, docker-tramp, ob-restclient, direnv, lsp, which-key, counselevil, magit, helm, flycheckorg,org-roam,ox-hugo,magitmagit,olivetti,elpher,vertico,helm,evil,company,orgvertico, consult, orderless, org, denote, marginalia, magit, emms, corfu, org-downloadansible-doc, terraform, magitMagit,org-mode,expand-region,multiple-cursors,consult (and previously helm),lsp-mode,ciderundo-tree, moe-themeprojectile, magit, lsp-mode, ivy, expand-regionMagit, ag, slimemagit, company, flycheck, which-key, spaceline, highlight-parentheses, haskell-mode, org-roam, magic-latex-buffer, rusticorg, org-roam, lap-modemagit, org-mode, which-key, dired, haskell-modeorg-mode, evil-mode, org-roam, lsp, direnv, elcordLsp, treemacs, org, magit, ercmagit,org modeorg-mode, org-roam, highlight-indent-guidesconsult, vertigo, eglotmagit, lsp-mode, elfeedmagit, helm, autocomplete-modemagit, lsp-mode, vertico, orderless, consult, org-roam, modus-themes, expand-regionauctex, biblatex, elpy, essorg, ivy, yas, slime, multiple-cursors,ryo-modalivy, org-mode, racket-mode, js2-modelsp, consult+marginalia+orderless+vertico, company, org, tree-sitter, flychecksmart-hungry-deletesage-shell-mode, doom-themes, doom-quit, org, evilmagit, paredit, dtrt-indentorg-roam, lsp-mode, verticoorg, magit, org-roamauctex, markdown-mode, lilypond-moderotate-textorg-mode, evil, magitMagit, Notmuch, Eglot, Org-mode, Vertico, Consult, Marginalia, Modusorg,org-roam,citar,orderless,vterm,coterm,diredGnus, TRAMP, jabber.el, Magit, dumb-jump, flycheck, rg.el, wgrepmu4e, magit, orgparen-mode,flycheck,ddskk,elpy,companyorg-roam, dap-mode, magit, diredhelpful, dash, clippy, transient, no-littering, avy, lsp, beacon, command-log-mode, counsellsp,eglot,use-package,smart-tabs-mode,flycheck,which-key,magit,beacon,hungry-delete,ace-windowavy, projectile, magit, idoOrg mode. Org mode. Org mode.magit,code-review,org-roamhelm, projectile, magit, dired, ctrlf, avy, evil, ace-windowOrg-mode,magit,helm,mu4e,dired+,undo-tree,ediff,org-roam,elpy,lsp-modeconsult vertico AUCTeXEglot, Elpher, GnusaucTeX, ido, markdown-mode, expand-regionpython-mode, flyspell, flycheck, clang-format, orgmagit, ivy/swiper, tramp, org-mode, which-key, vtermmagit,helm,company,helm-rg,perspective,projectileMagit, Cider, Evil, Projectile, Org-mode, use-package, Slimevterm,helm, company,magit,evil,which-key,geiser,lsp-mode,dashboardorg-mode, magit, helm, company-mode, paredit, dumb-jump, org-board, org-brain, ox-hugo, pdf-toolssly, helm, dired-sidebar, company, magit, smartparens, centaur-tabs, theme-looper, cledeevil,vundo,dtrt-indent,ws-butler,magit,lsp-modetramp, slime, ess, org-mode, erc, git-annexivy, counsel, easy-kill, move-text, git-gutter, git-timemachine, ggtags, ws-butler, disable-mousevertico,multiple-cursers,magit,consulthydra,which-key,orgeglot, Magit, org-roam, mentor, straight, vterm, EXWM, notmuch,evil, tree-sitter, eglot, multiple-cursorsorg-mode, magic, org-ref, org-roam, slime, deft, modus-themes, flyspell,helm, restclient, smartparens, lsp-mode, org-modeLSP, emacs everywhere, Magit, diredOlivetti mode, Hydra, windmove.el, counsel, move-text, all-the-icons, pandoc-mode (if it would work!), rainbow-delimitersorg-mode, org-super-links, org-linker-edna, helm, org-rifle, magit, eyebrowse, hydra, yankpadevil,magit,projectile,helm,flycheck,lsp-mode,which-keyvertigo, consult, orderless, embark, markdown-mode, rg, symbol-overlay, visual-regexp, wgrep, wdiredorg,denote,magitNeotree, Tuareg-modemagit, mu4e, elfeeddoom, evil, org, org-bullets, private-comments-mode, denote, indent-guidesorg-roam, evil, emacs-lsp, magit, vertico, treemacsNov.el, Cider.embark,corfu,lsp-mode,no-littering,evil,undo-fu,org-roam,transient,magitdrag-stuff, dashboard, multiple-cursors, magitorg-mode,lap-modeorg-mode,magit,cider,org-babel,popper,lispy,avy,tide,lsp-mode,yasnippetorg, magit, pdf-tools, use-package, bbdb, asyncorg-roam,mu4e,magit,dirvish,corfu,vertico,elfeed,org-super-agendamagit, lsp-mode, treesitter, forge, org-mode, org-mode-ui, centaur-tabs, quarto-mode, ess, passorg-mode, notmuch, magitEvil; ace-window; LSP integration packages; projectileSLIME, dired, EMMS, calc, nov, gnus, geiser, pdf-tools, paredit, TRAMPevil,lsp-bridgeMagit, Org mode, which-key, straight, rest mode,magit, various language modesorg, org-roam, tramp, calc, magit, cc-mode, lsp-mode, pass(word-store)straight, magit, ledger, calc, sly, slime, notmuch, package, eglot, TRAMPMaggit, lsp-mode,helm,projectile,helm-agorg-mode, web-mode, ledger-mode, projectile, zetteldeft, magit, mu4e, helm, expand-region, visual-regexpivy, counsel, org-mode, jupyter-emacsembarkmagit, vlf, lsp-modemagit, evil, lsp-mode, evil-snipe, super-save, projectile, org-modemagit,org,projectile,helm,pdf-tools,auctexmu4e,org-mode,docker,which-key,rusticevil, tree-sitter, eglot, company, magitorg-mode, nxml, evil now meowmagit,cider,smartparens,rainbow-mode,companyflyspell,flycheck,lsp-modemagit, dash, transient, org-mode, evilevil-mode, lsp-mode, org-mode, org-babeldired, transient, evil, magit, orderless, vertico, nyan-mode, ivy, org-super-agendacompany,dumb-jump,emacs-libvterm,evil,evil-collection,lsp-mode,magit,vertico,magit,browse-kill-ring,expand-region,multiple-cursors,undo-tree,atomic-chrome,projectOrgmode, evil, roamSLIME, Paredit, LSPmagit, evil, evil-collection, embark, ebib, citar, org-roam, no-littering, elfeed, git-timemachineconsult,meow,corfu,dired,general,magit,helpful,elisp-demoswhich-key, lsp-modeorg-mode,org-agenda,evil-modeorg-mode, org-roam, and any other Org-mode-related packages. :)magit, swiper, treemacs, multiple-cursors, org-roamlsp-mode, flycheck, org-mode, magitneotree, avy, ace-windowmagit;ivy;lsp-bridge;org-mode;ox-hugo;evil;lispy;prettify-symbols;consult, cider, ansi-term, magit, git-timemachineerlang-mode, org-mode, paradoxorg-mode, ess, auctexmagit, lsp-mode, github-review, mu4eMagit, projectile, evil,magit, org-mode, tramp, calendar, js-mode, python-mode, shell-script-mode, xml-modeevil,general,magit,org,consult,corfu,org-roamorg-mode, lsp-mode, helm, flycheck, ivy, company, use-packageOrg mode, MagitEvil, Org mode, CiderSlime, ido-completing-read+, company, neotree, pinentrymagit org SLIME gud.el (well that's built in) cperl-mode markdown-moderyo-modal,which-key,expand-region,company,delveOrg mode, avy, evil,magit, LSPmagit, slime,Avy, ivy, elfeed, notmuch, org-roam, lspOrg-mode, Evil, Magitevil, screenshot, novmagit, org-mode, lsp-mode, dap-mode, consult, marginalia, vertico, avyeglot, vertico, corfu, orderless, use-pacakge, straightauctex, company, ess, flycheck, ido, magit, multiple-cursors, no-littering, projectile, slimecc-mode,which-key,magit,eglot,go-mode,paredit,pdf-tools,org,rg,ace-windowEev, 0x0, dash, helpful, hydra, pdf-tools, rcirc, telega, vterm, xrevil-mode, org-mode, essexwm,org-roam,evil,geiser,corfu,cape,vertico,mu4e,libmpdelStraight,hydra,verticomagit, tree-sitter, flycheck, cargo, org, rustic, evil,undo-tree, smart-mode-line, recentf, treemacs, scala-mode, json-mode, magit, git-timemachine, restclient, orgOrg-mode, elfeedcopilot.el,crdt,org-mode,lsp-mode,nix-mode,magit,evil-mode,undo-tree,doom-modelinePDF Tools, Major Mode Hydra, Org Msg, Org-Caldav-Sync, Doom Modelinemagit; dired; platformio; fly-check;org, org-roam, org-cliplink, org-ref, ivy/counsel/swiper, smart-mode-line, magitorg,helm,xah-fly-keysorg-mode, lspMargit,Elpymagit, helm, hydra, ace-jump, mc, yasnippets, projectile, companyStraight, use-package, avy, org-*, vertico, consult, marginalia, magit, mu4eMPC.el, org, magit, ediff, minad packages for completions, ebib, project-tab-groups, tab-bar-groups, prot theme,...org, org-roam, undo-tree, magit, mu4eorg-mode, magit, helm, helm-dictionarymagit, tree-sitter, ido, helmorg, magit, harpoon, evil,Org Mode, org journalmagit, company, org, mu4e, ivymagit, vterm, rainbow-mode, beacon, org-superstar, ob-latex, jupyter, python-mode, calfw-howm, evillatex-preview-paneorg,org-roam,frog-jump-buffer,ag,magit,move-text,vtermorg-mode, magit, projectile, mu4e, tuareg, ivy, ace-window, company, flyspelltramp, org-mode, dired, magit, company, helm, multiple-cursors, try, yasnippetevil, magit, org-mode, slime, markdown-mode, vmd-modeHow come I could not choose 'ignore it I do not do that' up above.vertico, company, lspmagit, orgmodeMagit,lsp,multiple-cursors,org-mode,hydra,projectile,helmorg-mode,doom-themes,vertico,corfuswiper, magit, all of org-modemagit,avy,vertico,lsp-mode,evil-mode,consult,marginaliamaig, org-roam, pueue, spotify, lsp-mode, vterm, treemacsIvy,Elfeed,VTermorg, ivy, which-key, rg, markdown, posframes, format-all, lispyvilleMagit, org-mode, vterm, beacon, lsp, pass, multiple-cursorseglot, display-column-number-mode, package.el (built-in)magit,org-mode,helm,org-ref,perspective,geiser,slime,eglotMagit, 2048use-package, vterm, magit, counsel, swiper, projectile, flycheckcompany,flycheck,org, org-roam, maggit, evilorg, yasnippet, multiple-cursors, window-select, word-wrap, company,vi-tilde-fringe,ace-jump,magit,helm/ivy,idocompany, flycheck, lsp-mode, yasnippet, multiple-cursors, ace-windoworg-mode, lsp-mode, company, verticomagit,org,evil,which-key,general,companyorg, ivy, flycheck, eglot, tramp, smartparens, yasnippet, company, elfeed,IEdit, Company, IDO Vertical, Undo Tree, WGrep, Pareditmagit, projectile, cider, denote, flycheck, modus-theme, pdf-tools, pin-entryNoI have not explored the package environment very much beyond what I needed initiallyorg-roam, vulpeatelegamagit, org-mode, org-roam, org-roam-uiBeacon, Co-pilot, evilOrg mode, straight, magitno-littering, meow, corfu, popper, gcmh, exec-path-from-shell, magit, avy, olivetti, embarkorg,smartparens,cider,magit,fountain,selectrumorg, elfeed, pdf-tools, notmuch, denotefancy-dabbrev,magit,tree-sitter,ement.el,vterm,pdf-tools,notmuch,lsp-mode,consult,verticoorg, magit, notmuchhelm, magit, lsp-mode, rustic, projectile, tide, org-modemagit, tide, tramp, lsp-mode,org-mode, pythonstraight,company,evil,vertico,prescient,lsp-mode,magit,fussy,consult,projectileorg-mode, fountain-mode, mu4e, olivetti-mode, eww, diary and calendarAuto-tangle, doom-modelineMagit, reformatter, vertigo, embark,evil-mode, projectile, lsp-mode, swiper, ivy, magit, which-key, company, org-mode, direnvmagit, undo-tree, lsp-mode, envrc, consult, verticotldr, org-roam, undo-tree, magit, treemacswhich-key, lsp, use-package, fireplace, magitorg-mode,org-ql,org-roam,lsp,tramp,mu4e,dirvish,ivyevil, ivy, magit, company, eglot, wgrep, org-roamGnus, Magit, Org modeorg-mode, mu4e, elfeed, evil, magit, projectile, lsp, plantumlmagit,eglot,eldoc-box,org,treesittermagit, flycheck, lsp-modeevil, magit, org, vertico, org-roam, cc-mode, auctex, gnus, eglot, devdocs.elcounsel, define-word, magit, multiple-cursors, nano-modeline, olivetti, paredit, pdf-toolsOrg, evillsp, dashbaordMagit,pcap-mode,org-roam,lsp-mode,tramp-mode, which-key,gud-modemagit, evil, XKCD, company, harpoon, fireplaceemacs-evil, helm, projectile, magitmagit orgmagit, org mode, vertico,hungry-delete, iedit, multiple-cursors,org-reveal, vterm, vundo, diredmagit,org-mode,haskell-mode,orderless,emacsmagit, which-key- magit; - copilot (github); - lsp-dart; - rainbow-delimiters; - hydra (text-scale); - perspective.el; -projectile; more...helm,org-mode,magit,notmuch,beancount-mode,projectile,go-mode,go-dlv,flycheckA bunch of modes,magit, lsp-mode, projectile, org-modemh-e, cc-mode, html-modeiiiOriginal Python modemagit, gnus, bbdbperfect-margin-mode, scroll-on-jumporg-mode,magit,evil,deadgrep,trampExwm, evil, git-backupOrg mode, magit, dired ranger, mu4emagit, evil, lsp, doom-themes, vertico, consult, projectileMagit, lsp, treesitter, rotate text, multiple cursorsmagic,ivy,avy,lispy,eglot,orgmode,project.elavy, embark, evil, yasnippets, magit, org, vertico, consult, corfu, slymagit, cider, SLY, helmeglot, fussy, vertico, evil, which-key, tree-sitter, magit, corfu, rainbow-delimiters, apheleiaMagit, dired.browse-kill-ring, dired, expand-region, lsp-mode, restclient, sharper, sly, modus-themesMagit, companymagit, dired, merlin, slime, slynk, undo-tree, org, org-roammagit, diff-hl, ledger-mode, olivettimagit, tide, smerge-mode, lspyslime, sly, evilmagit,dtrt-indent,ws-butler,eglotmagit,spaceline-all-the-icons,restclient,exec-path-from-shellorg-mode,undo-tree,magitmagit,org,ace-window,slime,wgrep,pareditcorfu,vertico,consult,cider,lsp-modemagit,ledger-mode,org-modeESS, org-ref, org-modeMagic, vterm, objedMagit, Org, Ivy, Notmuch, Eglotorg-mode, treemacs, projectileorg-mode, magit, rainbow-delimiters, vterm, all-the-icons, all-the-icons-dired, docker-tramp, centered-window, emojify, emojify-logosMagit, lsp-mode, notmuch, org, embark, consult, ranger, org super agendamagit, use-package, yasnippet, projectile, ivy, multi-cursor, which-key, paredit, lsp, companyprojectile, evil-mode, lsp-mode, company, ivy, treemacs, tabbar,clang-format,cmake-mode,company,eglot,htmlize,eglot,magitevil, which-key, treemacs, magit, projectile, lsp, eglotSLY, Evil, General.el, and Verticoorg-mode,lsp-mode,EXWMMagit, paredit, slime, lsp-mode, ibuffer, ivy, counsel, swiper, pdf-tools, doom-themesevil, flycheck, magit, rainbow-delimiters, company, smex, neotree, projectile, solarized-themeorg-mode, org-journal, helm, deftorgmode, magit, slime, auctex, tramp, gnuscompany, eglot, crux, simpleclip, dashboard, solarized-theme, magit, projectile, flycheckorg-mode,yasnippet,hydra,consult,vertico,avy,embark,anzu,expand-region,smartrepmagit, eglot, orderless, consult, tramp, diredorgmode,org-roamEglot, lsp-mode, magic, vtermorg-mode,magit,evil,lsp-modeorg-roam, dired, elfeed, eglot, magit, gnusdeft vertico evil ligatures orgOrgmode Org babel Helm bibtex Org refGnus,Orgmodus-themes, evil, treemacs, projectile, lsp-mode, magit, doom-modeline, company, vertico, orgdeft, browse-kill-region, undo-tree, idomenu, html-helper-modeEvil, Straight.el, use-package, org, org-roamorg, magit, which-key, ivy, dashboardmagit, org, dumb-jump, projectileOrg mode,magit,mu4e,projectile,ledger-mode,company,evil,diredOrg-mode, magit, eglotmagit, emacs-jupyter, expand-regionorg, js2, prettier-js, yasnippet, ag, magitmagit,paredit,undo-treemagit, helpful, which-key, doom-modeline, dashboard, evil-nerd-commenter, vtermicomplete w/ fido-mode (builtin), ediff (builtin), pdf-toolsorg, magit, restclient, lsp-mode, dap-mode, tree-sitter, flycheck, rspec-mode, forgeorg-roam, projectile, helm, ivy, aceI don't think I couldVertico,consult,magit,embark,forge,ercOrg, magit, paredit, lispy, olivetti, avy, goto-last-change, deadgrep, Selectrum, expand-region.magit,lsp-*,org,hydra,perspective,projectile,helm,ivymagit, ivy, rg, beacon, god-mode, projectileelfeed, org-roam, magitOrg-roam, Org-transclution, Org-roam-ui, Yasnippetorg, flyspellmagit, evil, company, swipermagit, straight, org, restclient, marginalia, selectrum, consult, embarkorg2blog,vterm,rustic,verticoParedit, org, magit, lsp, projectile, yasnippets, undo-tree, verticoauctex, notmuch, geiserOrg-Mode, Helm, Magit, use-package, smart-tabs-mode, Swiper, SmartParensorg-mode, mu4e, magit, package, lsp-mode, consult, ediff, ace-window, org-msg, elfeedag, aggressive-indent, imenu-list, js2-mode, json-par, magit, nix-mode, recompile-on-save, scala-mode, swift-modeorg, agenda, ox-latex, org-roamorg-mode, magit, evil-mode, verticomagit, evil, treesitterparedit, ivy, yasnippet, geiseruse-package, racket-mode, org, sly, lsp-modehelm, editorconfig, cmake-mode, markdown-mode, mozcHelm,magit,vtermslime, use-package, pdf-tools, magit, ivy, which-keymagit,dired,flymake,projectileConsult, Vertico, use-package, straight, Magit, Marginaliaorg-mode, doom-modeline, elpher, exwmuse-package, lsp-mode, magit, flycheck, yasnippet, projectile, company, python-black and others.Lsp, avyorg-mode, org-roam, magit, vertico, lsp-modeorg-mode, magit, git-timemachine, auctex, org-ql, wgrep, avy, ido, workgroups2, projectileOrg mode, modus themes, org roam, auctex, undo tree, LSP mode, magit, org babel, emacs dashboard, elfeedlink-hint,consult-recoll,vertico,consult,embark,forge,cider,telega,exwm,circeOrg-mode,Rainbow,IvyRestclient, all of org, lsp-mode, vtermmagit, org-mode, windmove, lsp-modevertico,lsp-mode,company-modeevil-mode, magit, org-mode, org-roam, CIDER, restclient.el - the usual.lsp-mode, csharp-mode, company, magit, projectile, yaml-modeOrg-roam,lsp-modeOrg-mode, magit, rainbow-mode, minionsmagit, forge, eglotevil, auto-complete, elfeed, org-bulletsEIN, org-babel, Verticomagit,evil,org,python-mode,lsp-pyright,haskell-mode,lsp-haskellSlime, Sly, Magit, elfeedvertico, corfu, embark, consult, orderlessnyan-mode, lsp-mode, magit, elpypandoccrux, ivy, swiper, company, which-key, undo-tree, projectile, lsp-mode, magit, trydirvish, meow-edit, org-roam, pdf-tools, consult, vtermorg-mode, evil-mode, magit, lsp-mode, doom-modelineCorfu, embark, fussy, helpful, move-text, tree-sitter, undo-fu, verticomagit, lsp-mode, alchemistmagit,vterm,ivy,cider,sly,edwina,flycheck,emacs-notmuchmagit, lsp-mode, vertico, company, helpfulorg, lsp, projectile, projectile-ag, which-key, anzu, magitmagit, org-mode, evil-mode, lsp-modegnus,org,sokobanvertico, slymagit, slime, themesOrg-mode, org-journal, magit, tramp, ox-ssh, ox-hugo.magit, CIDER, eyebrowse, windmove, projectile, ivy, company, move-border, counselevil, magit is okorg,vertico,auctexparedit, slime, ciderrainbow-mode, beaconyasnippet, ivy, swiper, ada-modeess,idoorg, org-roam, org-drill, gnus, org-ref, bbdb, company, cdlatex, rainbow-delimiters, magitorg-mode, circe, elfeed, forecast, magit, mastodon, multiple-cursors, slime, telegamagit, projectile, evil-modestraight.el, org, elfeed, verticoMagit, org, org-roam, web-mode, geiser, emacs-jupyter.tramp (!), org mode (org roam), magitMagit, org-mode, org-roam, mu4emagit, use-package, evil, org, paredit, helm,Ada-modeexwm, evil, notmuchorg-mode, undo-tree, ivy, counsel, real-auto-save, dired, wdired, uniquifymagit, elfeed, mu4e, projectile, org-journal, telega.elc-mode (C++, Java, ...), LaTeX, Makefile, Pythonido (and amx-mode, Ido-ubiquitous-mode, &c.); magit; vterm; lsp-mode; the nano themesly,general,vlf,helm,dired-subtree,dired-narrow,which-key,pdf-tools,novorg,vtermiedit, markdown, rg,cc-mode, ledger, magitevil-mode, org-mode, magit, lsp-mode, org-roam, vertico++, projectilemagit, paredit, switch-windoworg-modern,org-presentTreemacs, LSP, Dirvish, Vtermorg, org-roam, mu4e, auctexledger-mode, org-mode, evil-modemagit,cider,avy,exwmMagit, projectile, lsp, orgmagit, org, lsp-mode, projectile, helm, flycheck, company, mmm-mode, web-modetram,flycheck,flymakeHelm, Ace-Jump, quelpa/ use-package.wgrep,embark,magit,avy,diredorg,org-roam,magitMagit, lsp-modeOrg-mode, Magit, Mu4e, Elfeedmagit, elpherMagit,lsp-mode,eglot,org-riflemagit, evil, modus themes, ivymagit, projectile, lsp-mode, org-mode, org-roam, org-babel, magitorg-mode, evil, projectile, yasnippet, lsp-mode, ess, magitorg-mode,lsp-modevertico, lsp-mode, company-fuzzy, sidelinevertico; orderless; marginalia;consult;embark;corfu;yasnippet;rainbow-delimiters;diminish;windmove;goto-last-change;git-gutter;multiple-cursors;rainbow-mode;anzu;magit;git-timemachine;org;org-roam;lsp-mode;project;calibredborg-mode, org-journal, php-mode, lspexwm,notmuch,lsp-mode,pdf-tools,rcirc,ewwmagit,evil,orglsp-mode, magit, corfu, consult, verticoflycheck, company-irony, smart-tabs, cmake-mode, glsl-mode, fish-mode, web-mode, csharp-mode, xclip, highlight-parenthesesVertico, ef-themes, beacon, ctrlf, helpful, elfeed, olivettiorg-mode, magit, projectile, ox-hugo, zen, workspaces, swiper/counsel-agorg, org-roam, flycheck, modus theme, ef-themes,Magit, project.el, tab-bar.el, Gnus, Org-modemeow, org, magit, eglotaggressive-indent, centered-cursor-mode, cider, companymagit,projectile,pdf-tools,multiple-cursors,auctex,lsp,helm,virtualenvwrapperlsp-mode projectile which-key ace-windowhelm, magit, ledger-mode, paredit, org-modeevil, helm, magit, org-mode, projectileprojectile, magit, verticonotmuch,cape,corfu,org,org-roam,tramp,vterm,diredorg mainlyOrg, org-roam, org-babel, sparql-modeOpam, Merlinorg-mode, dired, tramp, magitmagit, leaf, lsp-mode, mwim, anzu, avy, rustic, lean4-mode, prettier, treemacsorderless, marginalia, vertico, magitorg-mode, cider, magit, trampauctex, essslime-mode, ada-modecider, magit, evil, vertico, doom, orgabo-abo packages, evil, evil-mclsp-mode, magit, projectileprojectile, magit, undo-tree, darkroomelfeed, deft, magitmagit,org-mode,ciderevil,evil-collection,lsp-mode,ts-fold,geiser,flycheck,dired,eshell,vterm,magittempel,vertico,corfu,vterm,dired-narrow,nov,vertico,consult,orderlessmagit, forge, lsp-mode, flycheck, multiple-cursors, helm-ag, vertico, fussy, doom-modelineorg mode, org-babel, magitAggressive indent mode, slime, rainbow-delimiters, flyspell, dictionary-search, visual-line mode, use-package, ciderNotmuch,Eglot,Gnus,Orgmodeelpy, which-key, consult, exwm, hydraEmacs Application FrameworkVertico, cider, magit, paredit, embark, telegamagit, paredit, paren-face, highlight-parentheses, highlight-symbol, cl-lib, multiple-cursors, bsperspective, hydra, magitmagit,avy,dumb-jump,lsp-mode,restclient,undo-tree,swiper,which-key,helpful,projectileorg mode, magit, dired, trampmagit, use-package, eglot, go-mode, editorconfig, vertico, consult, marginalia, dumb-jumpmagit, lsp, rtags, orgMagit, Mu4e, Restclient, Yasnippet, Flycheck,leaf,projectile,flycheck,company,swiper,ivy,pos-tipMagit, Projectile, Ef-themesmagit, mu4e, Org ModeMagit, Org, windmove, framemove, buffer-move, yafolding, ws-butler, string-inflection, browse-kill-ring, multiple-cursorsevil,exwm,which-key,helmvertico, corfu, magit, org, which-key, helpfulorg-mode, org-roam, org-roam-bibtex but really I'm still getting started.LSP:Language Server Protocolorg-roam,julia-snailorg-bulletsOrg,Helm,DiredOrg-mode, roam, evil-surroundorg-mode, org-roam, ebib, eglot, treemacs, helm, org-ref, auctex, ess, mu4eorg-mode, magit, ivy/vertico, evil-texMagit,evil,spacemacs,lspAUCTeX, org, org-*, ox-*, flycheck & friendsorg-drill,Vertico,Embark,Consult,marginalia,Notmuch,pdf-tools,Magit,use-package,Cruxorg, try, dirvish, corfu, vertico, projectile, ciderCiderOrg, Magit, Avy, Ivy, Mu4e, ElfeedAuctex, orderless, consulttramp, org, eshell, eglot, wgrep, company, use-package, which-key, elfeed, with-editorparedit, sly, swiper, avy+ace-window, mediawiki, TRAMP, vtermcirce,jabber.el,sunrise-commanderVertico, marginalia,orderless,consult,magic,org,projectile,lisp-mode,metals-lspmagit, cider, expand-region, restclientOrg-mode, windmove, vc-mode, terminal, darkroom-modemagit,eglot,evil,which-key,exwm,org-mode,vtermmagit, ssh.el, slimeMagit, org-mode, lsp-mode, evil, org-roam,org, org-roam, elpy, magit, tramp, paredit, neotreemagit, corfu, vertico, consult, projectile, test-cockpitmagit, go-mode, json-mode, terraform-mode, ido-vertical-mode, multiple-cursors, highlight-parentheses, expand-region, rcirc, org-modemagit, projectile, helm, undo-tree, evil, avy, ace-window, which key, yasnippet, org-roammagit,elpy,org-mode,auctex,helm,multiple-cursors,keychord-mode,smartparensMagic, cclscompany,lsp-mode,magit,flycheck,org,modus-themes,treemacs-icons-diredmagit, org, smartparens, ivy, counsel, projectileOrg-mode, bazel-modeOrg, magit, vertico, consult, lsp-modemagit, helm, lsp, company, Rainbow delimiters, pdf-tools, moe-theme (highly changed)wgrep, anzu, better-defaults, AUCTeX,Magit, Deadgrep, Dired, corfu, eglot.Org-mode, evil, flycheck, magitCIDER, inf-clojure, clojure-lsp, org, magitmagit, restclient, multiple-cursors, avy, consult, org, eglot, docker-climagit,org-mode,org-roameditorconfig,page-break-lines,smart-tabs-mode,wanderlustdirenv, python-pytestWrite room. Fill adapt.ivy, counsel, treemacs, projectileshx,lusty-explorer,lispy,aggressive-indent,circe,hydra,magit,uniquify,windmoveeglot, aphaeleia, helpful, yasnippet, which-key, doom-themes, doom-modeline, corfu, vertico, dirvishess, elpy, polymode,magit,cider,flycheckevil, org-roam, eglot/lsporg, org-roam, cider, dired, magit, manyEvil, persp-mode, lsp-mode, eglotproject.el, magit, modus-themes, vertico, orderless, consult, org-cite, citar, org-roam, org-roam-bibtexevil, magit, doom-modeline, doom-themes, vertico, evil-multiedit, avy, org, eglot, vtermdired-sidebar, doom-power line, theme-looper, swiper, deadgrep,clojure-mode, haskell-mode, cider, org-modemagit, indium, web-mode, jupytermagit,org,expand-region,avy,ivy,visual-regexp,counselmagic, verilog-mode, org-mode, helm, org superstar, ggtagsmagit, projectile, direx, selectrum, deadgrepmagit, hyperbole, vc-fossilorg-mode, xah-fly-keys, vertico, elfeed, gnus, paredit, novMagit,ivy,projectile,smartparens, lspOrg Roam, Org Super Agenda, Declarative Org Capture Templates (doct), Which Key, Nyan-cat modemagit, yasnippet, multiple-cursors, racket-mode, paredit, helm, exwm, ace-windoworg,magitorg, org-journal, org-roam, lsp, c++-modeGuru-mode, lsp-mode, web-mode, osx-clipboard, trampCc-mode, markdown-modekubel, hl-todo, magit-todos, message-view-patch, Circe, elfeed-tube, flymake-vale, inf-elixir, envrcmeow,lsp-bridge,vertico,orderlessexpand-region, embark, marginalia, vertico, magitvterm, magit, emms, dwim-shell-command, eglot, vertico, pdf-tools, corfu, consultgo-mode,treemacs,lsp,companymagit, lsp, projectile, selectrum,Org, magit, multiple-cursors, counsel (swiper, Ivy), dashboardlsp-mode, evil-mode, org-roam, org-roam-ui, dap-modeMagit,notmuch,selectrum,projectile,cider,Clojure-mode,wgrep,goto-last-change, layout-restore, djcb-set-cursor-according-to-modemagit, helpful, nov, adoc-mode,Company, flycheck, helm, slime, visual-regexp, yasnippet, rainbow-delimiters, smartparens, paredit.solarized-theme,projectile,ivy,swiper,counsel,paredit,cider,clojure-modeconsult, vertico, corfu, devdocs, magit, gnus, eglotmagit, ivy, tramp, project.el, ack.el, xref, company, eglotdabbrev, org, magit, vc, rtags, key-chord, company, eshell, isearch, telega.elorg-mode, magit, exwm, eglot, tide, cider, slime, ivy, company-mode, sbbsEvil, vertico, consult, embark, orderless, org, org-roamMagit, slyescreen, org, magit, lsp-*Org-mode, magit, auctexivy, magit, projectile, workgroups2magit, org-mode, circe, slyOrg, jupytermagit, cider, slimeTRAMP, Gnus, org-mode, VC, project.el, nov.el, Flymakeexpand-region, editorconfig, link-hint, multiple-cursors, org-mode, quickrun, which-keyDired,neotree,magit (x1000), org-mode, evil mode in spacemacs (okay it's not a package), copilotundo-tree,dashboard,w3m,spaceline,powerlinemagit, zig-mode, geiser, yaml-modemagit, virtualenvwrappertramp,magit,duplicate-thing,multiple-cursors,expand-region,ivy,counsel,avy,dired-sidebar,vtermevil, org-mode, ciderhelm,companymagit, zenburn-themeorg-super-links, org-super-agenda, org-ql, helmOrg, magit, evil, company, vertico, org-roam, citar, org-citelsp-mode,projectile,multiple-cursors,yasnippet,flycheck,counselorgmode, magit, projectile, auctex, org-roam, org-journal, deft, yasnippet, denote, org-bibhelm, ag, windmove, popwinEvil, lspAvy, Company, Lsp-mode, Persp-mode, Org-roam, Appt, Calc, Paredit, Hyperbole, Magitsr-speedbar, markdown-mode, lua-mode, darkroom-modeMagit,eglot,multiple-cursorshelm,gnus,dante,projectile,flycheckslime, paredit, auctex, whiteroom-mode, tramp, helm, company, python-mode, ironyorg-babel,restclient,org-modeorg, org-roam, magit.magit, ef-themes, evil, counsel, swiper,Magit, avy, org-mode, projectile, helm, hydra, pareditmagit,vertico,org,elfeed,notmuch,lsp,company,yasnippet,mood-line,vtermvertico, consult, magit, denoteIvy, counsel, magit, lsp, evil, straight, evil-multieditmagit, flycheck, origami, tree-mode, org, evil, treemacs, lsp, eshellevil, dired, ivy, counsel, ido, yasnippet, org, magit, thingatpt, lspcounsel, elpy, flycheck, which-key, ivy, use-package,cider,magitmaxima, org-contrib, slime, xah-fly-keysmagit, projectile, helm, treemacsgeisersr-speedbar, elpher, elfeedmultiple-cursors, undo-tree, projectile, smartparens, etc.Org-mode, magit, eglot, denotelsp-mode, evil, magit, trampLSP with Pyright, Magitorg-fragtog, focus, citarorg-mode, jedi, yasnippet, verb, magitorg, neotree, ivy, company, jedi, merlin, eglot, iedit, which-keyHelm, lsp-mode, treemacs, magitProjectile, Magit, orgmode, evilorg-mode, magit, kubernetes-el, docker.el, avy, embark, consult, vertico, orderless, marginaliaorg, org-roam, vlf, magit, ivy-bibtex, zotxt, ess, wc-mode,magit,org,vertico,org-roam,mu4eorg, org-roam, beacon, helm-tramp, lsp, mu4e, multiple-corsors, ox-hugo, projectileorg-mode, org-roam, ox-hugo, hydra, evilhelm, helm-swoop, org,Magit, Org, Elfeed, Paredit, PDF Tools, Vterm, Eshell, God Mode.org-caldav, org-superagenda, org-chef, org-noter, org-pdftools, org-babelevil zenmagit, multiple-cursors, smex, (elpy but usage with anaconda is not straightforward)magit, consult, vertico, marginaliaOrg, org-roam, evil, swipedhelm, ace-windowAuctex,latexmk,ivy,lsp,company,treesitter,counsellsp, tree-sitter, magit, evil mode, dired, org mode, org auto tangle, centaur-tabsmodus-themes, magit, org-roam, which-key, elfeeduse-package, vertico, orderless, consult, corfu, corfu-terminal, mu4e, pdf-tools, paredit, magitAUCTeX, orgmode, progmodeSLIME, auctexorg-ref, sly, magit, ivy, powerthesaurusorg-mode, haskell, lsp, magitparedit,sly,dired,swiper,companyhowm,org-mode,pdf-tools,org-noterlsp-mode, magit, undo-tree, evil, org-mode, company, use-package, flycheck, web-modemarginalia,which-key,rainbow-delimitersengine-mode,bufler,immortal-scratch,marginaliaorg-mode, mu4e, direnv.el, magitorg, the various programming modes, eglot, eshell and other terminalsorg-mode,tide,vtermmagit, slime, org-mode, pareditorg-mode, notmuch-emacs, magitevil-vimfold, ligatures.el, evil, use-packageOrg, Gnus, EMMS, AUCTeX, Lemonmagit, sly, lsp, org-modegnus, magit, orgdashboard, doom-modeline, helm, ace-window, persp-mode, magit, vterm, lsp-mode, eglot, org-roamorg, gnus, emms, company, selectrum, marginaliastraight.el,use-package,eglot,vertico,consult,marginalia,modus-themes,denote,magitorg, org-roam, mu4elsp,rustic,pandoceww, elfeed, dump-jump, projectile, direnv, web-modeEvil, lsp-mode, which-key, general, verticomagit, browse-kill-ring, flycheck, py-autopep8org-mode,evil-mode,lsp-mode,vtermvterm,eaf,rimeOrg-mode, avy, elpy, ace-windowmagit, org-mode, web-mode, rspec-mode, golden-ratio.el, flycheck, undo-treeclang-format, expand-region, flycheck, git-timemachine, helm, magit, mu4e, org-mode, projectile, ws-butlerorg-mode,org-roam,magit,consult,marginalia,vertico,corfu,treemacs,cider,easy-hugeVertigoorg-mode,html-mode,visible-mark,org-babelEXWM,desktop-environment,ivy,helm,doom,pdf-view,lsp-mode,pandoclsp-mode,helm,magitmagit,org,nov,git-link,restclientlsp-brigeorg,org-roam,vertico,corfu,orderless,marginalia,consult,magit,which-key,tempelstraight, vertico, slime, corfumagit,lsp-mode,suggest,vertico,evilivy, lsp-modeevil, jedi, vertico, org-modeBeacon, lsp server, auctexmagit,elfeed,lsp-modeelfeed,elpher,ansi-term,org-bullets-mode,xkcd,gnus,tetris,dired,ewwAuctex, lsp, rainbow-delimiters, helmsupercite, gnus, java mode, sql modeProof general, company-coq, agda-modeorg-mode, org-roam, which-key, projectile (compilation aid is reason for not using built-in projects), auctexmagit, lsp, org-modediff-hlOlivetti mode, parredit, general major modesorg-mode, helm, magit, multi-cursororg-mode,cicre,multiple-cursors,ispell,ace-jump-modeorg mode, org-roam, Magitmu4e, paredit, ciderorgmode, cider, lsp, org-babel, magit, hs-minor-mode, projectile, org-roamparedit,which-key,org,magit,vertico,marginaliaaggressive-indent, auctex, corfu, doom-modeline, electric-operator, selectrum, rainbow-delimiters, use-package, vundo, which-keyMagit, vertico, consult, ef-themesorg-mode, vterm, eshell, tramp, dirvish, org-roam, elfeed, penmagit, auctex, lsp-modemagit, org-mode, lsp-mode, denote, modus-themes, helpfulOrg-mode. Flycheck.Org, org-roam, evilUse package Straight package Ivy/counsel/swiper Magit Ace Windoworg-mode, org-roam, magitorg,helm,emmet,projectileryo-modalsly, org, vtermmagit, zetteldeft, projectile, tideOrg-mode org-roamorg-mode and all the additions on org-modevertico, consult, which-key, projectile, uniquify, undo-tree, ace-windowEvil, evil-collection, Magitlsp-mode, helm, projectile, ace-jump-modeOrgmode,essProjectile, magit, org, mu4eembark consult dumb-jumpemacs-jupyter, org, slime, tramp, deadgreprgorg, projectile, magit,Roam, Helm, Org mode (if that counts :P)evil,magitorg-mode,consult,vertico,magitlsp, lsp-ui, orderless, verticocircecrdtmagit, LSP, org-modeOrgmodemagit,elgot,haskell-modeevil, magit, helm, helm-ag, fancy-dabbrev, vertico, orderless, paredit, bongoorg-mode,magit, org, typing-game, doctor-mode, tetris, consult, awesome-tray, pyim, shackle, helpful-modemagit, eglot, org, counsel/ivy, which-key, company, avymagit, cider, which-key, selectrum, eglot, restclient, plantuml-mode, company, smartparens, use-packagegmpl-mode, org-mode,Helm, Spaceline.evil,use-package,lsp-modefireplace,magit,projectile,lsp-mode,emacs-everywhere,vtermEbib, citar, org mode, org roam, leaf, outshine, EXWMox-rss, ido, helmmatlab-mode, paredit, geisercitar, org-ref, orderless, avy, transienteshell, ido, dired, magit, tramp, ace-jumpmagit, org-roam, which-keyGedcom, org, python, vertico, volatile-highlight, undo-treeztree, helm, magit, cua, undo-tree, builtin org-mode, diredcompany, dashboard, dired-sidebar, counsel, magit, org, pdf-tools, vterm,vterm, exwm, restclientess,org-mode,magitmagit, helm, undo-treevertico,eglot,corfu,kaolin-themedmagit, evil, orgeglot, web-mode, ctrlf, easy-kill, emmet-mode, deadgrepmagit, js2-mode, web-mode, sly, swank, diredevil, magit, rainbow-delimiters, minimap, crux, aggressive-indent-mode, flychecks.el,dash.el,evil-mode,which-key,projectile,helmBlack, py-autopep8, flycheckmagit, projectile, multiple-cursorseglot, vertico, consult, embark, tree-sitter, magit, multiple-cursorsMagit, dired+, helm, helm-agorg-mode, mu4e, org-journal, org-super-agenda, org-brain, org-roam2, company, multiple-cursors, vc, elfeedhelm,magit,lsp-modecoterm, haskell-mode, geiser, hyperbole, elfeed, which-key, disk-usage, dictionarymagit, orgmode, elfeed, pdf-toolsOrg,Magitido, python-mode, lsp-mode, flymakeAlchemist elixir, Erlang tool for Emacs, Terraform-mode, Selectrum, Format-allrainbow-delimiters, auto-complete, multiple-cursors, geiser-guilemagit,editorconfig,direnv,vtermMagit, Forge, Cider, Projectile, lsp-mode, mu4e, org, transient,gnus,sly,ef-themesmagit,smartparens,ivynotmuch, org, magit, vertico, consult, dired, evilmagit,eglot,expand-region,elfeed,projectile,company,bongoorg,darkroom,ediff,plantuml,graphvizlsp-mode, dap-modemagit, tramp, ciderorg-mode, magit, elpy, idoevil,org,auctex,undo-tree,try,avyOrg eglot lsp-modeprojectile, tide, highlight, lspI think i added one or two but i loose that configmagit, slime, org-modeThere are many, but e.g. cider, hydra, projectile, rust-parinferRacket Mode, Vertico, Orderlessorg,neotree,projectile,notmuchmagit,lsp-mode,vterm,jsonian,evilmagit, lsp, teletext, restclient, projectileexwm, gnus, magit, tramp, eww, gud, lockstep (NEEDS WORK, fails with MAGIT!)Corfu, Consult, Marginalia, Org, Web-Mode, eglot, magithyperbole, org-roam, org-ql, consult, eglotmagit, org-mode, vterm, diredEglot, tramp, flymake, projectdiredp, ivy, lsp-mode, swiper, magit, web-mode, pyvenv, which-keymagit, helm, org-modeEvil, vertico, expand-region,helm, imenuorgmode, magit, eglotdired org slimeevil-mode,eglot,magitorg-mode,org-roam,yasnippet,evil,magitmagit, dired, vertico, org-modecompany, helm, hydra, smartparens, spaceline, undo-tree, which-key, solarized-theme, yasnippet, zetteldeftMagit, Dirvish, Ivy, Org-mode, Org-RoamElpy, markdown for emacsmagit, org, lsp-mode, smerge-mode, swiper, ivy, multiple-cursors, paredit, dired+, deadgreporgmode, magit, conda.el, lsp-mode, projectilemagit,lsp,markdownlsp-bridge,evil,org-mode,xenopsexpand-region, eglot, flymake, modus-themes, company, multiple-cursors, vertico, consultEXWM, Org, helmmagit markdown asciidoc c++ mode orgorg-mode, lsp-mode, helm, projectileorg, magit, mu4e, consult, vertico, corfu, marginalia, eglot, avyxah-fly-keys, citre, ef-themes,Orgmode, openwithLsp, evil, polymode, org, rainbow-delimiters, auctex, agda-modeParedit, Magit, Modus Themes, Org, ESS, Eglot, Vterm, EMMS, Notmuchmagit, slime, git-timemachine,eglot, org modeMultiple-cursors, vterm, mu4eevil-mode, avy-mode, ace-window-mode, eglot, magitmagit, org-mode, tree-sitter, avy, eglot, elpherhelm, exwm, org, dired, vterm, calibredbledger-mode boxquotemagit, project.ellsp-mode, neotree, company, powerline, flycheck, rainbow-delimiters, pareditCIDER, projectile, org-mode, boon-mode, yasnippet, smartparensorg, undo-fu, vertico, consult, embark, which-key, markdown-mode, expand-region, ioccur, loccurMagit, Evil, which-key, generalelectric-pair-mode, ef-themes, which-key, vterm, pdf-tools, auctex, anzu, beacon, rainbow-modetree-sitter,orderless,corfuyasnippet, auctex, reftex, orgmode, dired+, mic-paren, pdf-tools, ido-modemagit,forge,pdf-tools, Gnus, ERC, EUDC, Cider, SLIME, shell-modemagit, clojure-mode, mu4e, cider, evil-mode, ivy, evil-escape, projectile, aggressive-indent-mode, smartparenslsp-mode, vertico, corfu, direnv, ef-themes, straight, consult, auctexorg-roam, cidermagit, projectile, straight, consult, corfu, embark, lsp-mode, org-mode, org-roam, evilundo-tree, wanderlust, magit, companyorg-mode, modalka, iedit, yasnippet, magit, lsp-modeorg mode, magitmagit, ivy, vertico, eglot, lsp-mode, org-roam, persp-mode (as used in doom emacs), more.lsp-mode,use-package,magit,better-defaults,company,org-mode,tree-sittermagit, projectile, treemacs, vterm, js2-mode, restclient, posframe, modus-themes, js2-refactor, tideEvil-mode, magit, lsp-mode, vtermOrg-mode, which, lsp-dart, elfeedmagit, notmuch, companion, rcirc-color, workgroups2, pipewire0I'm not sure they qualify as packages; I think they've long been builtin: gnus, w3m, org-mode auctex is probably the outlierStraight, isearch, consult, vertico, ripgrep,Magit, elfeed, mu4e, lispy, which-key, avy, org-mode, sly, dired, pdf-toolsMagit, orgmode, lsp-mode, yasnippet, auxtexmu4e, elfeed, org-mode, magit, dired, vterm, projectilespeck, auto-complete, pabbrev, smex (plus built-ins recentf, ido, save-place)magit, helm, flyspellmagit,which-key,vertico,org-mode,org-roam,company,projectile,lsp,hydra,yasnippetmagit, lookup, company, modeline, ivymagit, multiple-cursors, eglot, vterm, vertico, orderless, consult, wgrep, rglsp-mode, modus-themes, consult, vertico, avy, marginaliavertica, corfu, notmuchorg-mode, org-roam, denoteorg, muse, org-roam, magit, which-key, ripgrep, jbeans-theme, slimemagit, projectile, cidermu4emagit, eshellEglot, Counsel, Slime (terrible name), Magit, which-keyEglot, org, vterm, magic, paredit, use-package, ctrl-f, selectrum, Corfu, undo-treeNeotree, helmMagit,Eglot,Eshell,Dired,Project,VtermMagit, Magit, Magit, LSPmagit, vterm, tramp Though I believe magit and tramp are built in at this point.exwm, pdf-tools, Magit, ESS, nov.el, lexic, buffer-envOrg mode, Magit, modus-themes, doom-modeline, AucTeX, ESS, centaur-tabsorg-mode,dired,magitlsp-mode, treemacs, direnvmagit, org-mode, vertico, consult, marginalia, embark, orderless, evil-tex, rigpa, symexwanderlust, newsticker, ivy, use-package, slymagit, avy, counsel, which-key, direnv, multiple-cursors, tree-sitter, winner, helpful,meow, embark, orderless, magit, org-mode, dired, avy, iedit, wgreplsp-mode, magit, direnv, vtermflymake, flycheck, company, idomenu, multiple-cursorshelm, projectile, cider, lsp-mode, org-mode, elpy, restclient, ace-window, flycheckmagit, flycheck, org, org-roam, paredit, gcmh, which-key, rg, hl-todo, geisermagit, eglot, CIDER, modus-themes, org-mode, SLIME/SLYpersp-mode, magit,org, org-roam, magit, lsp, dash, s, f, projectile, ciderorg-mode, magit, vterm, dired, ivy, elfeed, cider, emmsHelm,orgAuCTeX, pareditEvil, evil-collection, org-mode, magit, projectile, lsp-mode, mu4e, vtermEvil, magit, ement.el, guixglasses-mode, doom-modeline, xah-fly-keys, counselMagit,Org-mode,AucTeXorg-mode, evil, magit, dumb-jump, pdf-tools, hydraOrg,company,hydra,org-roam,epa,ivy,lsp,magitorg, elfeed, mu4e, magit, yasnippet, dired, emacs-application-framework, modus-themes, telega, calibredbelpy, markdown-mode, monky, magit, python, go-mode, adoc-mode, lua-mode, yaml-mode, slimemeow, citre, emacs-rime, eglot, xeft, notmuch, telegahelm, projectile, modus-themes, vlforg-mode, elfeed, gnus, notmuchprojectile,org,magit,kubel,spacelinevundoexwm,ace-window,avy,ivy,lsp,org,org-roammagit,org-mode,org-roam,evil,lsp-bridgemagit, org-mode, org-noter, lsp-mode, projectile, gnus, bbdb, expand-region, pdf-tools, ya-snippetcider, lsp-mode, magit, vertico, marginaliaess, magit, org, yasnippedDenote, modus-themes , org-modeevil, org-roam, pdf-tools, lsp mode,deft, markdown, golang, orgundo-tree, highlight-symbol, lsp-mode, flycheck, proof-general, racket-mode, bind-key, use-packagelsp-mode,projectile,js2-mode,org-modemagit, projectile, trampAnzu, Corfu, Marginalia, rainbow-delimiters, undo-tree, Verticoorg-mode, hydra, keychord, which-key, counsel/ivy/swiper, yasnippetorg, bm, essdired, shell, dabbrev, info, man, orgvertico, consult, org, lsp-mode, magitorg-mode, hyperbole, org-roam, calc, ledger-mode, ESS, magitOrg-mode,magic,babel,lsp-modecompany, embark, eglot, org, rainbow-delimiters, selectrumorg-mode, eglot, cider, notmuchmagit, python-mode, org-mode, flycheckmagit,org-mode,lsp-modeorg-roam, notmuch, magit, paredit, pass, sly, ivy, counselMagit,eglot,corfuorg, gnusevil-mode, cider, org-modemagit, org, iedit, golden-ratioag, wgrep-ag, dumb-jump, flyceck-pyflakes, js2-mode, ws-trimvertico, consult, doom-modeline, org, visual-fill-column, iedit, eglot (just switched from lsp-mode)org, isearch, ido, smexmultiple-cursors, projectile, lsp-mode, restclient, treemacs, visual-regexp-steroids, yasnippet, ace-windowmagit, use-package, straight, org, vertico, corfuevil, magit, org, quelpa, enh-ruby-mode, circe, macrostep, nov, shackle, eyebrowseembark, consultI use undo-tree, sudo-edit, multi-term, stupid-indent-mode (I am not a fan of default emacs indentation), and the xah-lee text manipulation functions.Magit, go-mode, org-modeWriteroom, orgrefLinters and autocompleteexwm, emms, elpher, nov, olivetti, pdf-tools, org-noter, slime, w3mEvil, Org mode, projectile-railscider, slimeLsp, ivy,Org, magit, AucTeX, ESS, flycheck, yasnippet, aggressive-indent, powerlineorg, magit, evil, which-key, general, use-package, company, yasnippet, terminal-hereAvy, vertico, org-roam, dapevil,magit,ivy,projectile,cidermagit,evil-modeorg-mode,org-ref,org-roam,evil,ess,magit,pdf-tools,org-noter,mu4emagit, evil, org-mode, org-roamhelm, el-getMagit, Org-Mode, Dired, Which-Key, Lsp-Mode,Evil modeEvil, Magit, evil-cleverparens, org-mode, org-roamorg-mode, org-visibility, magit, vertico, consult, elfeed, elpher, flyspell, hippie-exp, mingusmagit, org, web-modeicicles, magit, dired, org,auctex, docbook, elfeed, ediff, eshell, org, package, which-keyleuven-theme,exec-path-from-shell,project,magit,auctex,web-mode,gnusIciclesdenote, elfeed, vterm, empvledger-modeevil, magit, vertico, lsp-modeOrg, magit, projectile, lsp, ivy, helm,,.slime, rainbow-delimiters, web-mode, org-mode,TRAMPess, org, org-roam, corfu, verticoMagit,org-mode,evil,lsp-mode,company,verticomagit and lspmagit org-mode evil-modeeglot,company,helmorg-mode, auc-tex, diredBuilt-ins! Org, project, gnus, vcmagit, bug-reference-mode, editorconfig, fill-column-indicator, modus-themes, vertico, consultIdo, visual-regexp, git-commit-mode,Evil-mode, treemacs, lsp (when it does work), magicborg,eglot,use-package,magitlsp-mode, envrc-mode, geiserivy, mic-paren, recentf, swiper, counsel, counsel-projectile, counsel-etagssudo-edit, magit, evil, lspExwmLanguage modes like go-mode and others. writeroom-modemagit, shell-mode, tramp, org-modeMagit,Helm,projectileorg-mode, ledger-mode, projectile, org-ql, org-superagenda, lspMagit, Helm, ace jump mode, yasnippet, treesitterpo-mode, raku-mode, csv-mode, markdown-mode, org-journal, graphviz-dot-mode, toml-mode, yaml-mode, dockerfile-modemagit, general, undo-tree, jupter, orgelfeedorg-mode, php-modeMeow consult+vertico+orderlessivy,swiper,org,org-roam,yasnippet,anki,straightorg-mode, jabber.el, emms, langtool.elorg-mode, ciderESS, mu4eEvil,org-mode,lsp-mode,treemacs,swiper,org-babelHelm, ein, lsp, autocomplete, companyorg-mode, projectiledenote, avy, hydra, tabspaces,LSP-mode, company, helpful, Magit, which-key, treemacs, vtermMagit,lsp-mode,imenu-list,org,forgemagit, org-mode, mu4e, elpy, venvmagit, lsp-mode, dap-mode, vertico, tree-sitter, vterm, org-mode, pdf-tools, yas-snippet, ementorg, eglot, god-mode, magitlsp, magit, mu4e, ivy, orgorg, magit, multiple-cursors, ido, restclient, yasnippet, markdown, geiserEvil, Clojure mode, LSP mode, Neo tree, Helm, IvyMagit, ag, multiple-cursors, projectile, web-mode, org-mode.Magit, projectile, hydra, counsel, ivy, ag, straight, markdownflycheck,projectile,magit,avy,company,lsp-mode,modus-themes,ivy,vertico,corfuorg-super-agenda, org-modern, lsp-mode and evil-modemagit,yasnippet,ace-window,projectile,python-black,rubocopdired, magit, ivy, evil, org, flycheck, cidermagit, org, lsp, ivy/counsel, s/f/map, straight/use-package, win-switchyaml-mode, rust-mode, flycheck, use-package, rustic, companyAvy, Magit, Polymode, ESS, eviluse-package, org, modus-themes, doom-modeline, all-the-iconsorg-mode, magit, mu4e, dirvishmagit, org-roam, agda-mode, s.elmagit,eglot,evil-modemagit, ace-jump-modemagit, elpy, tramporg-mode, modus-themes, ef-themes, flycheck, lsp, neotree, magit, pdfviewanki-editor, org, org-roamMagit, lspmultiple cursors Emme Magitivy, swiper, lsp-mode, ccls, company, slime,ido, magit, lsp-java, cc-modemultiple-cursors, undo-treeCompany-mode, treemacs, Flycheck, web-mode, projectile ♥, flyspellsmex, magit, helm, company, projectiledoom-modeline, org-roam, magit, magit-todos, flycheck, which-key, flyspell-lazy, dictionaryorg-mode, magit, cider-mode, auctexOrg, mu4e, ess, magitorg,consult,vertico,orderlessmulti-cursorDon't really have any. I use mostly vanilla Emacs.elpydiminish, ggtags, rust-modeMagit, org, org-roam, vertico, consult, embark, transient, which-key, straight, vtermcider, consult, eglot, helpful, literate-calc-mode, magit, rustic, straight, use-package, verticoMultiple-cursorsMagit, ESS, multiple-cursors, Eshell, org-mode, avy, notmuch, PDF Tools, smartparensmagit, deft, tree-sitter, yasnippet, fly-check, lsp-modeMagit, god-mode, paredit, slime, prodigy, git-link.magit, emacs-slack, flymake, undo-tree, projectile, dumb-jump, auctexOrg-ql, org-transclusion, magit, org-web-tools, pdf-tools, xenops, helpful, org-bookmark-heading, pcre2el, avynotmuch, org-mode, magitmagit,exwm,lsp-mode,org-mode,ewwmagit, org, helmorg,org-superstar-modeorg, magit, vterm, leaf, migemo, eglotdumb-jumporg auctex doom-themego-mode, company-lsp, hcl-modewhich-key, ivymagit, lsp-mode, neotreeevil,avy,ivy,hydraeglot, magic, elfeed, VC, projectelfeed, mu4e, paredit, org-mode, org-roamorg-mode, magit, cidereglot, vertico, consult, corfu, orderless, magitmagit,lispy,sotlisp,yasnippets,ivy,gnusorg-mode,magit,jedimagit,smart-parens,company,multiple-cursors,sly,projectile,dumb-jump,vtermelcord, rustic, doom-themes, doom-modelineevil-surroundorg-mode, magit, web-mode, eglot, go-modelsp, ivyMagit, transient, org-mode, eglot, evil, projectile, embark, consult, verico,org-mode, mu4e, org-roamflycheck,companyorg-roam,magit,cheat.shorg-mode, elfeed, projectile, yasnippets, which-key, emmet-mode, graphviz-mode, plantuml-modenlinum,buffer-move,comment-dwim,fill-column-indicator,smooth-scrollingxah-fly-keys, magit, org-mode, lsp-modemerlin, wanderlust, geisersly,magit,notmuch,vtermMagit, straight, evil, vertico, company, (LSP - although it's unusably slow)org-mode, php-mode, html-mode,web-modeMagit, LSP, Meghanada, EJC-SQLVertico, magit, tide, org-roamorg-mode, magit, mu4eorg-mode, project, magit, web-modeI use vimMagit, org, lsp, hydra, helmMagit, org-mode, lsp-modemagit, lsp-mode, org-mode, projectile, parinfer, tree-sitter, yasnippetorg-mode, straight, modus-themes, use-package, vertico, elfeed, mu4e, org-modernorg, magit, rinari,dired, magit, org, modus-themes, ef-themes, olivetti, diff-hl, lsp-mode, dynamic-cursor, rainbow-modeauctex,ess,lsp-mode,magit,mu4e,org-mode,org-roamAt the moment, as I go through the SICP for 109th time, I'm using geiser and guiler heavilyorg, company, ivy, swiper, counsel, deft, magit, cider, vtermnxml, magit, orgvertico,consult,wgrep,tramp,orderless,gnus,perspectivemagit, consult, modus-themes, eglot, popperEglotEss, slime, auto-completeorg, ivymagit,undo-tree,helm,projectile,which-keyorg-mode, restclientmagit, corfu, vertico, auctex, orgvundo, marginalia, exwm, elfeedorg evillsp, magit, projectilecompany-mode, benchmark-init,org-roam, org-ref, org-noter, helm, use-package, straight, emacs-jupyter, magit, yasnippet.helm, dashboard, lspMagit, multiple-cursors, lsp-mode, flycheck, companyMagit, elpher, org-mode, Gnus, mu4e, meow, org-babel, uxntal-modemagit,evil,ivy,vtermHełm, companyOrg, ivy, lispy, pdf-tools, company, flycheck, which-keyMagit, telega, org-roam, lsp, multiple-cursors, vterm, notmuchParedit, slime, ciderorg-mode, magit, dumb-jump, multiple-cursors, avy, ivylsp-mode,dracula,anki-connect,helm,slimemagit, jiralib2, request.elmagic, aggressive-indent, ws-butler, expand-regionorg-mode, magit, slime, reftex, auctexeglot,magitorg-mode, calfw, auctex, magit, lst-mode, vterm, outshine, deadgrep, selectrum, yasnippetauctex,avy,buffer-env,focus,inspector,magit,slime,shell-command+,writegood-modemagit,lsp-mode,org-mode,markdown-mode,projectile,smartparens,undo-treemagit, vertico, elfeed, git-timemachine, diff-hlAuctex,cdlatex,org-roam,calibredb,org-notermagit, consult, embark, wgrepmagit,vertico,lsp-mode,dap-mode,tree-sitter,company,evillsp-mode, tree-sitter, org-mode, org-roam, magit, elfeed, evilprojectile, org, elglot,Magit, selectrum, prescient, projectile, lsp, flycheck, org-modemagit, restclient-mode, avy, ace-windowhelm, magit, flycheck, ggtags, orgtramp,helm,projectile,magit,ddskk,expand-region,evil,expand-region, corfu, vundo, highlight-indent-guides, vterm, dumb-jumpWhich key, nano modeline, counseluse-package, which-key, magitMagit, puni, embarkVertico, eglot, embark, magit, consult, org, tab-barevil,org,vertico,embark,avy,which-key,spaceline,web-mode,generalI repeat, I don't use packages. The only customization I did was change the color scheme.org, avy, eglot, magit, web-modeOrg,magit,anzu,expand-region,Olivetti,vertico,marginalia,consultorgmode, helm/ivy, any package bygithubalphapapaMagit, eglot, ebib, biblio, multiple-cursors, auctex, markdown-mode, csv-mode, unfill, abc-modeorg-journal,lsp-mode,org-roamevil Beyond that, I mostly use my own forks that have diverged quite a lot from the original repos. Typical examples include org-mode, helm and synnosaurus.org, pdf-tools, org-roam,Magit, evil, ledger, org, projectGnus, Org, Calc, Zetteldeft, ERC, Magitmagit,enh-ruby,evilvertico, consult, ef-themes, exwmcider,clojure-mode,lsp-mode,evil,magit,consult,embark,marginalia,vertico,org-super-agendaAuctex, swiper?, ivy's pop up M-x, exwmMagit, dired, emms, dictionaryorg-mode,org-roam,magit,dired,evil-modeorg-mode, notmuch, lsp-mode, org-babel,org, lsp-mode, elfeed, mu4e, crux, magit, au text, vtermorg, magit, gnus, denote, modus-themes, nov, backup-each-save, helm, which-key, trampevil, org, magitivy, which-key, company, elpherEmbark, evil-mode, vertico, consultbeacon, embark, vterm, vertico, consultAUCTeX, lsp-mode, mu4e, org-mode, magitevil, org-roam, consult, corfu, vertico, embark, sly, geiser, lsp-mode, vtermpdf-tools, vterm, org, magit, cdlatex, auctexmagit, YASnippetivy, magit, web-mode, mu4e, elfeed, slynotmuchmagit, gnus, cider, projectile, org, ido, eshell, sql, ercgeneral.el, straight.el, helmmagit, org-mode, enh-ruby-mode, multiple-cursors, notmuch, nyan-mode, org-msg, robe, ef-themessymbol-overlay,diff-hlorg, org-drill, synonyms, elfeed, htmlize, persist, adaptive-wraporg-mode, magit, clang-formatmagit, org-mode, eglot, paredit, vertico, corfu, auctex, which-key, orderless, slyavy, helm, projectile, counsel, tuaregorg-mode, evil, consult, which-key, org-roam, orderlessmagit,org-mode,lsp-mode,ivy,org-mode,nano-theme,js2-modestraight.el, SLIME, Geiser, org-mode, org-roammagit, lsp-mode, org-mode, ercHelm, eglot, flycheck, companyexpand-region, magitorg-roam,magit,auctex,cdlatex,notmuch,arxiv-citation,elfeed,ercprojectile, org-mode, magitgnus, flyspellace-window, expand-region, yasnippet, magit, which-key, csv-mode, org, slime, cider, go-modeEvil mode, cider, org-modeparedit,cider,rainbow-delimiters,golden-ratio-scroll-screen,expand-region,slimemagit, org, projectile, tideEvil,org,lsp-mode,company,projectile,magit,general,git-timemachine,ranger,restclientOrg mode, Magit, Tramp, SLIME, Paredit, KubelOrg,use-packageOrg-mode, eglot, evil, org-roamevil, avy, emacs-libvterm, vterm-toggle, counsel, company, dired-sidebar,Magit, tramp, eglot, consult, YAsnippetorg, eglot, elfeed, auctex, pdf-toolsevil, auctex, org, which-key, magit, tree-sitter, org-roamMagit, Meghanada, Org, Hierarchy, BUI, Fountain, Slack, Tramp,org-mode, which-key, counselorg-mode, magit, projectile, eglot, vertico, consult, marginalia, corfu, which-key, helpfulorg-mode, eww, eshell, gnus, erc, calclsp-mode,org-mode,org-babel,org-roamido, dired, vc-mode, org-mode, eglot, company-mode (trying corfu), projectilesmartparens, paredit, rust, company, slime, magit, ivy, projectile, consultMagit, git-time-machine, lap-modeorg-mode, magit, lsp-mode, eglot, vertico, orderless, consult, embark, marginalia, corfuido, org, clean-aindent-mode, markdownMargit, Gnus, dired, exwm, racket-mode, Shell-Mode, ivyorg, org-roam, paredit, rainbow-delimiters, notmuch, sly, god-modeevil, avy, ace-window, org-modeorg-mode, org-roam, projectile, magitvertico, consult, modus-themes, cruxido, web-mode, rainbow, rmail, tramp, diredSLIME, magit, projectile, nano-mode, web-mode, markdown-modeEmacsorg,magit,sql,ox-jira,acejumpibuffer,undo-tree,ggtags,ieditproject, org-mode, notmuch, auctex, magit, consultmagit.el, flyspell.el, ivy.el, cperl-mode.el, lsp-mode.el, restclient.eluse-package,lsp-mode,org-mode,org-roamorg-mode, flycheck, lsp-modehelm, slime, smartparens,CIDER, Org, parinfer, evilmagic, ESS, lsp-mode, evil, evil-collection, org-modeLsp,vertico,orderless,wich-key, expand-regionOrg, Erc, Notmuch, Vterm, Modus themesmagit, eglot, tramp, muktiple-cursorsorg,ement,nim-mode,elfeed,org-babelevil,org,org-noter,citar,calcEvil, org, magit, ement.el, org-roam, direnvOrg-mode, ob-cfengine3, ox-jira, mu4e, magic, forgebongo,howmorg-mode,viper-modemagit, projectile, lsp, company, prescientmagit, org, which-key, auctexeglot, elfeed, embark, magit, nov, org, org-roam, osm, vterm, yasnippetmagit, org-mode, tuareg, merlin, vterm, notmuch, exwm, org-roam, ido, verticoExpand-region, multiple cursors, orgmode, company, vertico, elgantt, org-ql, magitevil, magit, vertico, org-mode, lsp-modecider,paredit-modeorg, magit, evil, consult, corfu, eglotleaf.el, lsp-modeorg-mode,evil,ivy,use-packagemagit, proof-general , company-coq, merlin-mode, tuareg,org-mode, treemacsorg, slime, magit, paredit, form-feedmagit,info,org,shell,dired,hcel,pdf-toolLSP (primarily for scala), and the thing that pops up intermediate choices for keybindingsorg, auctex, dired, setup.el, corfu, vertico, cape, consult, marginalia, eglotconsult, corfu, embark, lsp-mode, lispy, magit, modus-themes, orderless, rustic, emacs-libvtermhelm,org-mode,lsp-mode,projectile,calfwmagit, org, projectile, eglotivy, counsel, elpy, flycheck, magit, kubernetes-el, use-package I also like dash.el, s and f, but they seem mostly redundant with builtin but less attractively named function groupsorg-roam,which-key,avy,helm,mu4e,password-store,emmsorg roamuse-package, helm, company, magit, eglot, git-timemachine, nyan-modeOrg mode, Evil mode, Lsp mode, cider, vertico, consult, Magit, projectileOrg roamorg-mode, helm, magit, general, vertico, lsp-mode, projectile, modus-themesorg-mode, magit, helm, swiperMeow, Eglot, Consult, Notmuchuse-package,helmOrg, tramp, iedit, vundo, vterm, multiplecursors, slime, nano-theme,slime,merlin, org, dired-single, eshellorg-mode, org-roam, mu4e, exwm, ember-mode, web-mode, lsp-modedon’t really have anyorg-mode, magit,projectile,counsel,counsel-projectile,helm-projectile,ivy,pbcopy,string-inflection,web-modeMagic,vertico,consult,embark,corfuorg-mode, org-roam, LSP, rustic/rust-modeorg,org-roam,treemacs,magit,evil,company,elfeed,ledger-mode,lsp,mu4eevil, magit,ciderorg-mode; ess; vertico; rgrep; consult; zk; bongo; pdf-tools; org-tree-slide;Magit, orgmode, trampmode, diredMagit,slime,org,LSPmagit, lsp, treesitterevil, magit, wichkeyorg, dired, magit, projectile, slime, erccompany, lsp-mode, flycheck, consult, vertico, yasnippetOrg-mode. Helm. SLIME.Org mode, org-roam, tramp vterm projectile, diredmagit,vterm,projectile,helm,lsp-mode,company,trampuse-package, pandoc-mode, vertigo, savehist, jupyter, deadgrep, centaur-tabs, org-bookmarks-extractor, ox-reveal, magitcompany, eglot, undo tree, which-keyorg-mode, mu4e, pomodoro, org-roam-mode, evil, yassnippet, pdf-tools, org-note, org-ref, (any and all relevant programming modes)org-mode, vertico, corfu, mu4e, which-key, popper, evil, magit, consult, org-roamProjectile,web-mode,magic,emmsorg-mode, which-key, vertico, consult, restclient, modus-themesMu4e, geiser, rainbow-delimiterscorfuorg, deft, slime, direddenote,lsp, emacs dashboardorg,magit,auctex,helm,use-packageivy, company, slime, org-roam, magitmagit, smartparens, nano-theme, nano-modelineOrg mode, CIDER, magit, vterm, dired, counsel, helm, doomcalibredb, deft, doom-modeline, elfeed, lastfm, org, org-journal, org-wc, rainbow-mode, yasnippetmagit, projectile, hydra,Evil, Consult, Verticocompany-mode, org-roam, yasnippet, helm-bibtex, irony-modeMagit, ido, ciderCIDER, org-mode, magitevil, magit, corfu, vertico, prescient, org-modeMagit, counsel, embark, consultcider, org-roam, hydra, magit, smartparens, helm, perspective, projectile, lsp-modedirvish,eglot,corfu,cape,vertico,consult,general,evilorg, org-roam, magitlsp-mode, magit, treemacs, use-package, treesitter, rainbow-mode, auto-package-update, nvm.elEvil, YASnippet, magitorg-mode, org-roam, lspmagit,multiple-cursors,helm,helm-projectile,helm-ag,undo-tree,helm-swoop,which-key,org,matlab-modepython-mode, helm, lspevil, magit, lsp-mode, embark, treesittermarkdown-mode, texfrag-mode, pandoc-mode, eaf-pdf-previewer, treemacs, verticoheml, projectile, treemacsorg-noter, look-mode, magit, num3-mode, pulsarwriteroom-modelsp-mode,evil,deer,incr.elDash.el, magit, org, request.el, ivymu4e, org-contriborg-roam, asciidoc-mode, lsp-modetramp, org, dired, flymake, magit, cedet, slime, companystraight, company, eglot, Proof General, marginalia, consult, which-keyElfeed, mu4e, undo-treeuse-package, magit, org-mode, helm, guide-key, solarized-theme, go-modeorg-mode/org-super-agenda, paredit, magit, lilyponddashuse-package,helpful,indent-guide,counsel,swiper,rainbow-delimiters,multiple-cursorsmultiple-cursors, avy, wgrep, ivy/counsel/swiper, magit, ctrlf, rg, restclient, org-roam, org-roam-uimagit, evil, org-mode, lsp, slime, geiser, popperevil,vertico,orderless,magit,marginalia,lsp-mode,corfu,embarkThe ones I made :”)org-modern,sokoban,use-package,auctexevil, drag stuff, treemacsMagit, orgmode, diredOrgmode, lspmagit, org-mode, modus-themes, org-roam, org-roam-uimagit, multiple-cursors, undo-tree, ctrlf, avy, helpful, company, yasnippet, eglot, dumb-jumporg-mode, writeroom, rainbow-delimitersorg-mode,magit,mu4e,eshell,dired,vertico,consult,embark,vterm,ciderorg-mode, magit, mu4e, pdf-tools, emacs-jupyterEvil-mode, kap-mode, consultuse-package, expand-region, org-modeevil, magit, undotree, expand-regionorg-mode, elfeedOrg, magit, rest-mode, org-roam,which-keyorg-mode, lsp-mode, rust-mode, magit, helm?org,magit,which-key,helmwinum, lsp, evil, helm, projectile, magitlsp-tailwindcss, org-roam, org-roam-ui, screenshot, magit, projectile, ivyclhs ein elpy bbdbmagit, eglot, realgud, general, vertico, consult, corfu, mu4eorg, magit, auctex, yasnippetamx, company, doom-modeline, highlight-parentheses, magit, symbol-overlay, volatile-highlights, which-key, ws-butler, yasnippetauth-source, display-fill-column-indicator-mode, savehist-mode, save-place-mode, recentf-mode, evil, magit, vertico, vterm, mu4eavy, key-chord, which-key, magit, editorconfig, whitespace, project, orguse-package, mood-line, all-the-icons, org, dired-subtree, vundo, ibuffer, ido, magit, god-modeMagit, smart parens, lsp, org, org-roam, yasnippetorg-mode, org-roam, olivettiundo-tree, lsp-modezenburn theme, ivy, yasnippet, a lot of lsp* stuffEIN, helmorg,org-ql,lsp,back-button,flycheck,helm,languagetool,monokai-theme,rghelm, magit, flycheck, company, yasnippet, tramporg-mode, magit, rust-mode, flycheck, scad-mode, modus-vivendi-themeivy, consul, cider, avy, magit, org-mode, projectile, swiper, lispyorg-mode,dired,magit,org-roam,notmuch,emms,elfeed,lsp-modeorg-mode, org-roam, org-roam-bibtex, auctex, lsporg-mode, straight, eglot, helpful, password-store, vterm, 0x0, magit, mu4e, ement.elorg, org-pdftools, magit, gnus, undo-tree, modus-themes, outshine, company, proof-general, smartparensorg-mode, evil, lsp-mode, lsp-bridge, company-mode, python-mode, org-roamelpher, elfeed, notmuch, olivetti-mode, modus-themesorg, magit, vertico, consultuse-package, multiple-cursors, mu4eeglit, visual-regexp, company, helmIsearch,Vertico, marginalia,embark, Outline-mode, Golden-ratio, avy, Orderless, Edit-indirect, vimish-foldOrg-mode, elpy, web-mode, Magitmagit, emacs-lspmultiple-cursors, agorg, helm, helm-swoop, multiple-cursors, eglot, magit, company, hydrahelpful, which-key, use-package, magit, org, trampmu4e, org, lsp-mode, leuven-theme, rainbow-delimiters, company, tree-sitter, poly-modeorg-mode, rustic, pdf-toolsDired, eshell evil-mode lsp-mode org-mode damn almost all emacs packagesLsp, magit, evilAucTeX, PDF tools, Magit, Jupyter, code-cellsmeow, org, avy, ace-window, consult, minad, vertico, org-roam, org-translusionmagit, org-roam, consult, ace-window, avy, orderless, vertico, eglot, tree-sitter, pareditbshell, corfu, eglot, magit, smartparens, tree-sitter, xcscope, osx-browse, aggressive-indentDenote, magit, elfeed, modus themes, mini modelineOlivetti, Org-mode, mu4e, deft, elfeed, eww,org-mode, magit, trampneotree,helm,helm-gtags,org-journal,dracula-theme,fill-column-indicator,centaur-tabs,mu4e,magitRainbow-delimiters, flycheck, minimap-modeOrgmode, evil, auctexMagit, avy, vterm, tide, LSP modeorg, org-roam, org-roam-ui, evilflycheck, smartparens, company, expand-region, web-mode, iedit, multiple-cursors, indent-guide, verb, yasnippetsdoom/evil, magit, counsel, lsp, python-mode, vterm, ace-window, org-mode, emacs-jupyterMagit, paredit, evil*magit, org-journal, dash, which-key, helpful, undo-tree, no-littering, zenburn-theme, macrostepEvil, magit, org-mode, helm, ivyOrg, calcmagit, slime, lsp-modeorg-roam2, org-download, vtermevil-mode, evil-motion, org-modeorg, vertico, exwm, passCIDER, projectile, doom theme, tramp,Magitorg, flymake, auctex, use-package, yasnippet, magit, edifforg,org-roam,magit,hyperbole,eev,gnus,transient,meow,guix-emacs,leafmagit, vertigo, consult, corfu, org-roammu4e, org-mode, org-roam, slimetreemacs, org, org-roam, mu4e, auctexorg-mode, cider, slime, company, ...Org mode, CIDER, Clojure mode, tramp mode, LSP, Magitmagit, eglot, lsp-mode, evil, use-packageauctex, markdown modecitar, denote, xah-fly-keysOrg-mode, denote, marginalia, vertico, order less, which-key, helpful, consult, embarkmagit,org,tramp,git-link,pdf-tools,god-mode,writeroom-mode,elfeed,novwritegood-mode,ledger-mode,elfeed,elpher,org-wc,vtermivy, projectileMagit, org-mode, SLIME/SLY, company, ivy, evilOrg, org-capture, org-refile, yasnippetosm-search, elpy, org-mode, hackernews, spray, pdf-tools, wiki-summary, dad-jokevertico, orderless, marginalia, emacs-rime, avy, consultorg-autolist,org,magitorg,eshell,evil,helm,magit,evil,lsp,orgmagit,sly,vterm,which-keymingus, counsel, magit, dired+which-key,vertico,consult,magit,org-mode,org-roam,avyorg-mode, mu4e, super-agendamagit,org,mu4e,which-key,auctexWould never get approval to install packages at work so I just don't use them anywhere.LSP, prettier-js, hledger-modeMagit, vertico, embark, consult, nyan-modeorg-mode (which is now a builtin I guess), which-keyelfeed, goto-chg, magit, mmm-mode, pdf-tools, vterm, yasnippet, zenburn-themeOrg mode, Aux, ExwmMagit (by far the best package ever written), org-mode, perspective.el, which-keyrust-modemagit, restclient, orgFlymakeOrg mode, helm, elpy, hydra, straightModus themesnomagit, deft, zetteldeft, circe, notmuchmagit, git-gutter, ivy, which-keys, eglot, gnus, company- built-in: org, modus-themes, gnus, project.el - 3rd party: magit, eglot, corfu, ebdb, pulsarOrg Roam, vterm, magit, elpy, lsp-modeOrg-mode,verb,js2,prettier,ya-snippets,exwm,evil,org,vertico,consult,sly,lispy,multiple-cursors,vterm,writeroom-modeconsult, vertico, helm, ivyconsult,vertico,magit,diredevil, magit, org, org-roam, haskell-mode, flymake, use-package, dired, meoworg-mode, org-roam, org-transclusionwhich-key,org,hydra,beacon,magit,openwith,rainbow-delimiters,guide-key-tip,git-gutterorg-mode, magit, projectile, evil-mode, org-agenda, mu4e, helmorg-mode, helm, vertico, lsp-mode, eglot, flymake-grammalecte, langtool-mode,org-mode, helmevil, magit, lsp-mode, org-mode, org-roamorg-mode, denote, which-key, marginalia, consult, eglothelm,company,lspuse-package, evil-mode, doom-modeline, lsp-mode, highlight-indent-guidesI'm a big fan of pophint for modal navigation: https://github.com/aki2o/emacs-pophint I also love to read gopher pages in Emacs with Elpher: https://thelambdalab.xyz/elpher/Evil, mini-frame, lap, multiple cursorsnotmuch, magit, org-mode (and a whole lot of stuff built on it), focus, fancy-narrow, lsp, olivetti, brutalist-themeLSPmagit, expand-region, multiple-cursorsorg-mode, magit, notmuch, helmcounsel, elfeed, org-fragtog, vterm, yasnippet, org-modern, lsp-modemagit, lsp, evil-mode, vertico (anything by minad)org-mode,org-ref,org-roam,mu4e,elfeed,magitdired, vtermiedit,paredit,yasnippet,citeprocmagit,calcorgmode, magit, eglot, consult, general, evil, verticomagit,evil,company,vertico,consult,lsp-mode,yasnippet,org-mode,presient,fussymagit, undo-tree, which-key, composable, vterm, eglotmagit, eglot, helm-projectile, rainbow-parensMagit, LSP,org-roam, lsp, xwwp, calibredb,ef-themes, notmuch, ace-jump, verticoOrg-mode, Vertico, lspNot in Doom: Evil-owl, Swift-helpful, theme-changer, svg-tag-mode, clipboard2orgEvil,Bufler,Vterm,Undo-tree,Consult,Magit,Orgorg-mode, gnus, slime, psvn, calc, VCSLIME, rg, evil, paredit, lispy, tide, js2-mode, avy, erc, vcorg,beacon,org-ql,org-super-agenda,vertico,yasnippet,org-mode, helm, helm-gtags, magit, ace-jump.lsp-mode, ace-window, elixir-mode, alchemist, projectile, multiple-cursors, neotreebrowse-kill-ring.el, real-auto-save.el, interaction-log.elhelm,beacon,doom-modeline,ws-butler,hungry-deletehelm, which-key, dap-mode, deferred, yasnippet, dired, eshell, companyMagit,projectile,cider,eglotCIDER, paredit, ag, flycheck, slime, yas, clojure-mode, clojure-snippets, find-file-in-projectmagit, auctex, web-mode, enh-ruby-mode, (lsp), (projectile-rails/-speedbar), (helm?)Org-mode, revealjs, magit, lsp, tramp, evil-mode, hydra,Orgmode, denote, modus-themeMeow, avy, vertico, consult, embarkmodus-themes, tree-sitter, embak-mode, vertico-modecorfu,magit,forge,yasnippet,lsp-mode,elfeed,org,citar,org-roam,mu4eMagit,mu4e,diredorg-mode,ido,sr-speedbarevil, magit, org-mode, lsp-modeeglot, flymake, flycheck, company, ivy, slime/sly, vtermorg-ql, ess, elfeed, theme-magiceglot, which-key, org-novelistmodus-themes, magit, lsp, eglot, evil, avy, consult, vertico, marginaliadumb-jump, ggtags, company, whitespace, imenu-listClojure-mode, swiper/counsel/ivy, org-roam, which-key, general, evil, projectileHelm, projectile, magit, lsp, use-package, companymagit, consult, avysly, cider,Org mode, gnusorg-mode, org-fc, notmuch, projectileMagit, cider, Slime, company, aggressive-indent,
If you write packages, how you you decide which repositories to submit it to (if any)?

GNU ELPA, NonGNU ELPA, MELPA, etc.

String
MELPAGNU ELPAmelpaMelpaN/An/aGNU ELPA, MELPAgithubGithubNot sureNonGNU ELPA, MELPANoneEase of submissionMELPA, GNU ELPAAlways MELPA.-GitHubGNU ELPA, NonGNU ELPAGnu elpaN/aGNU ELPA,MELPAelpaNonGNU ELPAMelpa. It seems like the most popular, and AFAIK you dont have to do the FSF paperwork.My packages are for personal use, so I don't submit themFirst option would be GNU ELPA. Second option would be NonGNU ELPA.melpa due to low barrier of entryI'd use Melpa or my own githubalways melpahow frequently I hear about it from package creators (i.e. most popular) less bureaucracy to submit and maintain (release)Elpa if they support or are related to elpa packages. Melpa for standalone packages. More recently: no repo until I get uptake.I wrote a package once but I didn't know about this. I think someone else opened a PR to add it to MELPA. I no longer maintain it and an official version of it was eventually made.Have only ever submitted to MELPA. Did so because that has the lowest (perceived) overhead and none of the packages I've authored have been used widely enough that I would consider it valuable to spend any more time on packaging.I would probably start by self-hosting on Git.When I started writing packages the only alternative was MELPA, and I never moved my stuff to ELPA. I could, I guess.I don't write packagesI don't write code useful for others.MELPA only since I very very seldom write ElispMELPA for simplicity and reachI don't write packages yet.GNU ELPA or MELPA. It depends on the packageI suggest it to the Emacs developer mailing list. If it is accepted to GNU ELPA, that's fine. I'd go for NonGNU ELPA if I'd hope for contributors who don't want to give away copyrights, and for MELPA if the package wouldn't fit ELPA (e.g. if it "endorsed non-free software").Using a tube of lube.Have submitted a single one to MELPA, it struck me as the most common repository (didn't research it further).I only publish source repositories.Either they don't go to MELPA (if I don't deem them interesting to the public) or they do go on MELPA. I'll have to evaluate NonGNU ELPA though.I used to submit to MELPA, but now I just install them from straight. Most of my packages are for me. But those that have a wider audience I have submitted to MELPA.not really deciding, whatever easiest,I use MELPA mostly because getting FSF assignment for all the contributors is a hassle, and I see no advantage.Would like to contribute both to ELPA and core Emacs. I am still working with my employer to get FSF copyright papers signed.melpa is what I mostly use myself, github is fine for me tooGNU Elpa or Melpa. Hate multiple repo crapp. Why not stay with one GNU for official and another more open-minded?Github, and recommends that users copy to their .emacs.dUhhh.... MELPA by default?I have written several packages; converting some of my more potentially reusable customizations to try to fit in with the Emacs way; I maintain my own local custom package repository, but frankly, package.el is broken. comments carrying semantics; versioning is ridiculous. interaction with customize, etc. I looked at straight.el and use-package but haven't yet cracked the case; I am dubious of the ELPA review process as being too onerous and hostile, and similarly dubious of the MELPA review process, i.e. that is there is none.MELPA, because it's easy and I understand the process.I decided not toI don't know enough about these ins and outs.Melpa, because I don't have to sign FSF copyright papers.Melpa because that's the one I get my packages from.I would go for Melpa, because that's the one I most come across. Wasn't really aware of the others.By licenceI post to them all if it's not too much trouble. The GNU ones are too much trouble.Although FSF and GNU have been hugely beneficial to programming, there are times when I think their rigidness works against them, so I would start with MELPA.I use vimI am used to Melpa by habbit (no particular reasons...)MELPA - low friction, widely used, dealing with FSF is never not a pain in the neck and only worth it when contributing to something already hosted thereI just put up a git repo for straight or quelpa.MELPA provides a better balance of reviewed functionality vs bureaucracy for me at this timeI try to avoid the GNU bureaucracy at all costs.I run my own.I have written 3 packages but not submitted any to a repository. I guess I haven't seriously considered doing so yet, maybe because I don't think of the packages as stable, and because I'm not sure where to start with that submission process.I submit them to MELPA because the process is very easymelpa, because it is easiestMy own elpa, jcs-elpaI have no idea, I am using MELPA because it hast most packages, so I guess I'll submit it to MELPA aswell.Going to submit to MelpaI have written one. Melpa, not much thought behind it, at the time that seemed best.Whichever has the lowest barrier to submissionEase of submission. Whichever repository is the least work.I need to read more to knowI would submit to Guix.GNU Elpa is the best as it's the official source. NonGNU Elpa, second. I avoid MELPA.I prefer something quick with low requirementsDon't submit any (yet)I put them on my github and pull them with straight. I sometimes mention them in reddit comments so others can as well. I've heard that melpa is the easiest to get a package accepted to, but never actually bothered.Core Emacs if possibleMelpa is easiestNever submittedI don't, I only use ELPA but I don't want to fill out the legal name papers to contribute my own work, so I simply make the source available online on forges.I would prefer to use the repositories which are included by default and have the highest level quality control. Ease of update and FSF copyright assignment are secondary concerns to the package being available and working correctly.I have my own private repository on my own site. It's pretty niceI've only submitted to MELPA in the past: I should explore the others too.I have mostly avoided it out of desire for simplicityMELPA, because it seemed like the easiest one to deal withI would probably start with MELPA as barrier to entry seems lower, then consider also doing ELPA to make it easier for users to get.If I wrote something worth distributing, such as a mode useful OOTB, I'd likely try getting it into ELPA or the main Emacs tree.I don't really intend to ever submit my own packages to GNU ELPA, because I dislike the copyright assignment thing and intend to avoid it inasmuch as I can, and also because (and this applies to NonGNU ELPA) I really dislike the consistent attitude of "I don't know you or your code, but you named your software something that I don't understand and you should change it". So, if I ever get around to actually publishing my stuff, it'll be MELPA.I submitted to MELPA, because I cannot understand the process of submitting to ELPA which seems to involve mailing list and some git repo permission grantsEase of submission, so by default it's just MelpaMELPA, low entry barrier & clear review process.As long as it doesn't involve having anything to do with the FSF and some of the persons behind it, I don't careMELPA, because many packages I used is published on MELPAI don't submit them I just use them myselfJust submit to MELPA when I feel the package is readyWhen I do work on Emacs I try to just work upstream for the most part;that is, in Emacs itself.Only Melpa, process is much easier.GNU ELPA is the ideal place to submit packages. MELPA is fairly easy and is necessary when the package depends on other MELPA packages.minor packages - just submit to MELPA because it's easyMelpa, just because it's easyjust always assume MELPA.Personal repository. My employer refuses to sign the FSF paperwork, so I am stuck in limbo, despite wanting to contribute to core. Despite this, please don't say something silly like we should abolish the FSF copyright.not do. It is difficult process.I think the FSF staffs are annoying. I would either submit to MELPA or just upload to a GitHub repo.MELPA?I would probably use MelpaAccording to my familiarity. I am now more familiar with Melpa. The accepted licensing scheme is also important.I have only written a single package that I "released", but I did not submit it to any package because I did not expect it to be widely applicable.MELPA, because I use it when search for packagesI submit to MELPA, because it was by far the easiest process when I submitted my first packages. Perhaps the process at Non/GNU ELPA is easier now, so I will check it out if I write a new package.melpa, since I can contribute via PRDon't, just put the code on GitHubI would just use MELPA, because it is wiedely used and easy to submit.The package I have written I submitted to melpa because it seemed the easiest.I decide by ease of setting up.I would try melpa first.I have considered submitting to MELPA as that is what I use to pull packages down. GNU ELPA would be out of the question as I do not want to sign my IP away to another entity, especially if I am to continue to maintain the package.GNU elpaMELPA: Due to it being easy.I submitted my one very small package to MELPA because the process seemed easier.I don'tI haven't submitted anywhere...ease of processI only submit to MELPA due to its lower barrier.NonGNU ELPA and MELPA. Getting approval for the FSF paperwork is too onerous.I haven't through laziness, generally provide 'straight.el' recipes paperwork has been signed for contributions to master primarily for pgtkMelpa for simplicity and habitMy github for the time being. Maybe one of the repos eventually.MELPA because it's the easiest. I haven't looked into the process of submitting to GNU ELPA.I recently started writing my first package for using 'b4' Linux Kernel helper script. _When_ it is ready, I probably will try to get it to MELPA. Since most blog post about publishing packages show MELPA. I did not really put a lot of thought about storing on MELPA in contrast to others mean, though.MELPA let's me keep complete control.Melpa seems default at the moment. Hit that first.I usually don't, but if I do I usually go with MELPA just because I've done that before.MELPA to avoid FSF headachesI always use MELPA, I think it's the most popularMy packages are not in a good enough shape to submit them.I usually choose repositories which allow submission and contribution from anybody interested without signing copyright related papers.I don't, I believe in decentralization.I have written packages but have not submitted them to repositories. They are on github.All packages I've written have been for company internal languages, never published.Only host on GitHubI’d look for the most Freedom respecting repositoryMelpa, it is easiestMost of my code is not in packages (I don't use package.el myself), but I do maintain some packages in MELPA. I prefer MELPA to GNU because I value freedom, i.e., I don't want to require copyright assignment or other non-technical hoop-jumping from contributors.I went straight for MELPA because of less frictionMost FOSS and copyright-compliant (ie no Github copilot or license violating services)Ease; I mostly submit to Melpa, because it's painfully straight-forward, but I'm trying to submit some changes to GNU Elpa, currently, because the package lives thereThe repository with the least hassleMELPA and NonGNU ELPA, as these seem to be where most people install from.MELPA because it is low frictionI have never submitted to any of those, mainly out of a sense that people wouldn't be interested in my packages.Melpa has most up to date packages, would likely be thereThought about submitting to MELPA, but the list of requirements is really long, not worth for a niche package.Meloa, widely used but not militant on licensingWhat is easiest? Melpa because it's on github.MELPA, or no repositories at all.I've only considered MELPA, and it's because MELPA finds my code where it sits.MELPA is the place where any type of package can be hosted, no considerations of license type or to have to assign CopyrightOn MELPA, but it wasn't my decision -- an interim maintainer probably put it there.Probably keep it as a github recipe first and submit it to NonGNU ELPA, as the process is fairly straight forward to submit there(https://emacsredux.com/blog/2021/08/11/submitting-a-package-to-nongnu-elpa/). As they are widely supported repos I would like the packages to be present there creating a friction less installation process for my future self(or anybody else).pastebini don't generallyBy simplicity of submission and overall usage in the communityI've just been using MELPA be defaultMELPA has been convenient and the process has been excellent and helpful. I haven't considered NonGNU ELPA since I don't know much about it. ELPA is probably not relevant for my packages in any case since they aren't especially "core," and the copyright stuff would likely be a barrier but only because I don't claim copyright on my work and there is therefore nothing to assign to anybody else.I was just creating them on GitHub, until someone suggested I should push one of my packages to MELPA, which I did. In theory I would wait until the package matures before taking the time to put it on MELPA or related.MELPA, it’s easiestI submitted to MELPA since I thought it is the most extensive and widely used oneTry to make my work as widely available as possible, so stick to gnu standards but use non-Gnu repos tooI dont' submit them currently, but I'm currently preparing to.MELPA because it requires least effort from meGNU ELPA or NonGNU ELPAJust MELPA, since almost every other package I use uses it, and there seems to be much less friction to contribution.I just submit to Melpa because it's easy and seems to get the job done.Easy for the user to installI've been downloading form MELPA and I never had any issues. If I write a package, I'll submit it to MELPA.Melpa, it's easyJust MELPA, because I'm familiar with the processI tend to just put it on MELPA.MELPA (to be honest just because of ease of use and inertia)ELPA if I get to decide. Will not contribute to software that is not free and copyleft.I use gnu elpa unless some contributor doesn't want to sign the CA.MELPA because it's quick and easy to submit. The feedback from the review process is really helpful too.I just put them on gitlab since they are primarily for meMelpa, since it had a very low barrier for submission.MELPA or none at all for the sake my own convenience.Where most people will be able to easily download and install it, combined how easy it's for me to get my package up. I.e. MELPA.Look where others submit theirs, ask why and decide if I agree.Melpa, if at all. Avoid the others due to the processes.My package was made mostly for myself and it uses a public API so I didn't know if I would somehow represent them by developing something for them. So I never submitted it anywhere public. Had I chosen somewhere to put it, maybe on Github and on my own Guix Channel.i just submit to melpa because that's what i know.Always melpa because it's open and welcoming.So far I've just submitted to MELPA since it has the friendliest submission model, is rolling release, and preserves git history when installing stuff with straight.elNonGNU ELPA because it is enabled by default, MELPA before that because it was the de facto default. These days MELPA is less attractive.Someone else submitted a package I wrote to MELPA. I did not really decide on anything.I don't, just leave it on GitHub.I prefer Elpa first and foremost, potentially Melpa also if it would be a package I work on a lot since I could get faster feedback from the community that way.what is easiest and doesn't require buerocratic painEase of submission and installationAlways MELPA, the process is very easy.I have only submitted to MELPA because I can’t be bothered with the administrivia for other reposasdfI put my package under the MIT license (sculpture-themes), so I submitted it to MELPA. Plus MELPA's stringent standards are pretty cool.I don't, instead, I suggest installing them via straight.elI just submit to MELPA to minimize hassle.I submitted one package to melpa because it's the biggest one. But these days I would probably not submit anywhere becasue all package managers in use can install from sourceI have a package ob-racket but I never submitted itUsually, no repositories, or MELPA is preferred, however MELPA's review and copyright process isn't really something I look forward to with packages I use in my own setup.Melpa because it is the easiestI only submit to Melpai keep them for private useNo clue.Only own repo. Only Mit license.melpa, b/c no-nonsensethe less troublesome firstI'd submit it to my personal GitHub at mostI don't; I write for me and there is little interest in what I am solving (or else it would've already been solved)Most popular one MELPAWhichever one is not controlled by GNU or the FSF, beyond that I don't care.I haven't written any packages since the invention of these repositories.I wrote a package once. It was one of the first direnv packages and his since been supplanted by a better one. I submitted to MELPA because it was straightforward (low ceremony) to do so and integrated trivially with Github.I hade only tried submitting to MELPA because it seemed to be the easiest way.no idea!MELPA, mainly because my other packages are already there.Always GNU ELPAI'm not sure. I'll probably contribute it to the MELPA because it has a more open package policy and is automatically built by Nix.I maintain crafted-emacs, but that isn't technically a package. If I were to choose, I'd choose GNU ELPA or NonGNU ELPA.I searched the Internet and then found MELPA documentation and it was very good and comprehensive so I submitted my package there.I have written one package, have not submitted it anywhere.Prefer fsf associated such as gnu elpaI suppose I would try to submit them to GNU ELPA, as I trust the FSF. So far, I have only written one trivial package which only works with Doom Emacs, so it is not in any package repository yet (this is also because I don't know if the quality of its code is good enough).haven't thought about it yetI'll submit it in the GNU ELPA repository, the devs there will decide if it's apt for NonGNU/GNU ELPA.I usually just use MELPA, easier to submit packages.Didn't do that. Only published code on githubGitHub, sr.htI have a repository on codeberg.org. I don't like *ELPA. Using (add-to-list) and (require) are easy enough for me.melpa b/c it onboarded easilyHave my own self-hosted gitea instance.It has been done by the community for me.All my packages are on Melpa. Their documentation and tooling made the process very accessible to me. I'm convinced that the quality of my beginner-ish code improved because of it. I much (much!) appreciate the review and the helpful advice I get when I propose a package for addition.GNU elpas, for ideological reasonsMelpa cause its easy and fast and I pull most of my packages from there anyway.MELPA for less hassleNever done so before but generally MELPA because it hosts most of the packages and i'm unfamilliar with the elpa process and the FSF.Mostly out of convenience. MELPA is the easiest to submit to, therefore it is my go-to repository.Melpa, just because it's quite simple to get something up. When I write a package, I usually don't know what its final shape and functionality will be, and if it will actually be useful. Melpa has a low barrier to entry, allowing me to get it in the hands of users who don't build from source, and get some feedback early on. (As most default setups have Melpa already configured.)GNU project is trusted party regarding keeping packages fully free software so I don't see issue to submit it to it or even any other repoGenerally MELPA for its ease of use. I haven’t publicly put out a new package in a long time, though.MELPA is easiest.Melpa if i dont intend it to ever get into emacs built-in.MELPA had a clear contribution process, I’ve never looked into the others. It seems the most open to contributions.Highly likely MELPA since I may not be allowed to assign copyright to the FSF. ELPA if I could.to my custom archiveI do not want to sign any papers. Beside that, it does not matter.Usually MELPA because it allows me to store my package wherever I want so I can get continuous integration. This way, any change to my package is tested (lint + unit-tests).github, it's easier - my code is already thereJust any available and compatible.In general I go for MELPAMELPA because I don't really want to give power and maintainership away right at the start to FSFI don't write packages but i'd take a look at all of my options before doing so.MELPA, since I didn't sign the FSF copyright papers (yet); if it's still possible to upload the package to NonGNU ELPA, then I'm not aware of that (again: yet).Only really bother with MELPAELPA, MELPAI'd probably submit to all who I thought would likely accept.GNUMELPA first, one it's stabilized, move to GNU ELPA if possibleWhere most users will be able to see the packageemacs coreThe simplest is MELPA.NonGNU ELPA, since it is enabled by default since version 28.At the moment of publishing my package MELPA seemed easiest.Which one is easier to useCurrently NonGNU ELPA. Once the paperwork is complete (I'm in the process), I'll publish to GNU ELPA, or NonGNU ELPA if for some legal reason GNU ELPA doesn't accept it.Fundamentally I wouldn't want to go through many hoops to submit my packages (which makes it highly unlikely I would wan to submit packages to repository that require FSF paperwork).I do not submit to a package repo. I have only written one package and it is likely to not be useful to myself only.MELPA, GitHubMELPA because review process is less stressful and feels less public than emacs-devel mailing list.Emacs coreonline git-repo only, then on request by usersOnly GNU ELPAI just add to MELPA, because it's easier.I want my packages to be available for everyone, so I add the to GNU ELPA. If I were to inherit a package, where the CA was not signed, I would choose NonGNU ELPA instead.ELPA, NonGNU ELPAJust go with melpaI never take the time to publish my packages. Btw, I never found easy documentation to do it.OUIJAMost of my packages are from MELPA, and that is also my primary target.gnu elpa, melpaI would pick the popular repositories.Melpa seems like the default (non gnu one)Melpa because its the most popularI’d push it to GitHub or another source forge and probably leave it at that.My packages are only on MELPA, because IIRC back then this was the only option.I've just used MELPAUsefulness to my workflowMELPA Easy, clear process, no ping pong with the mailing list. I have an abandoned copyright assignment somewhere in the pipeline. I almost wanted to do it. I don't understand why FSF can't find a better way after decades of being focused on IPeverything to melpaI always submit to only MELPA.Previously Melpa, as nonGNU elpa didn’t exist at the time & it was straightforward to do soI normally submit packages to MELPA because it is the repository I'm most familiar with. I would like to submit to GNU ELPA and NonGNU ELPA, but always had the feeling packages had to be of much higher quality and usefulness compared to MELPA so I have never tried.If I decide to write my own package, I surely will submit it to MELPA due to it's ability to pull and make my plugin available to everyone through GitHub repository. In short terms: Less moves from me in order to make everyone else happier. But, if somebody asks me to publish it to GNU ELPA as well, I will try to do my best (It means, my plugin will have GPL license from the start)Mine are all small. So I commit them to GNU ELPA to make sure they'll remain freeEase of contribution/uploadI would probably consider NonGNU ELPA first since I like the FSF's stance on software freedom, but to my understanding GNU ELPA are packages considered part of Emacs and thus probably not applicable.I just use MELPA because it seems like the standard, and I haven't signed the FSF copyright papers.Melpa is the easiest, so that's where I submit.MELPA - it has more users, maintainers and packagesQuit simple, I prefer to contirbute to core, if 'relevant'. Otherwise, I prefer to place packages on Elpa if eligible, and otherwise (from now on), I would submit to NonGNU ELPA , AND, Melpa. However, I write many 'packages' that are very useful, but I do not find them 'polished' enough to submit them to any repository yet (not counting github as repository here). Although I try to support, advocate and align with the 'FSF policy/philosophy' as much as possible, lack of time and resources prevent me (for now) to transfer my 'development repos' away from Github.MELPA has lowest barrier of entry and I have no qualms of using it whatsoever compared to the others.entry barrier -> i used melpa.Always GNU ELPA so that they can be bundled with Emacs releases someday.I do not want to further enmesh myself with the GNU community or the FSF until Stallman is gone.I don't know. I'm not there yet.I just go with melpaI just put it on MELPA, for convenience. It's not GNU necessarily, and I believe there's still paperwork involved.I've only authored one package, and I submitted it to MELPA because it was the easiest process for me to understand. It's my impression (although I admit I haven't done much research) that it is more... bureaucratic?... to submit to GNU ELPA what with copyright paperwork and the like. I preferred MELPA's process which was closer to the "make Pull Request, make changes according to maintainer review, done" process I was used to when contributing code to projects.My one package is in MELPA. I chose MELPA as my package doesnt seem "core" enough that it should be in ELPA/NonGNU ELPA.I use melpa because it seems to have less burdenmelpa: It is easiest to just file a pull request. I preferred marmalade, but that mostly ceased to work.None i just put on githubMy packages are generally not production ready so they are not on any of those.Good question, for historical reasons I just submitted it to Melpa. It never occurred to me that I could submit it somewhere elseSubmitting to MELPA is the easiest and thus my preferred way.GNU ELPA I don't trust repositories whose packages are rebuilt automatically from the git repository of each package, without a maintainer to check the code quality. This poses the same kind of problem as package managers dedicated to programming languages (npm, pip, etc). I don't want to encourage it.At first, I went for MELPA, since I thought they would be more willing to include my package. Now, I just ask for GNU ELPA.MELPA has been a source of vitality for the community for years, so it is my first thought for where to submit.MELPA as it contains most packages that I enjoyMELPA is easy to get into, so I publish there. I don't like all the ceremony with publishing, though, so I've moved to a git-based policy: install my package using Straight (or MELPA, since that pulls from GitHub).melpa most closely aligns to my views on software.If I would submit a package it would be NonGNU or Melpa. I don't like that me and all contributors need to have a fsf copyright assignment. It greatly slows down development! Just look at the use-package situation to get all the paperwork from contributors https://github.com/jwiegley/use-package/issues/282Melpa, and just forget about the rest.I only know how to submit to melpa so melpa it ismelpa... I'm pretty done with GNU/FSF/RMS dogmaSimplest easy access with non-profit licensesMELPA, since I think it would be the default for new/unstable packages.I submit to Melpa because I am familiar with it.I submit only to melpaI'd just stick it in melpa but maybe nongnu now. Also I HAVE considered submitting FSF paperwork but will not. The previous question did not let me express this.i submit to gnu elpa whenever possible, to make sure it gets a wide and easily available distributionI don't if I do it would be what people who use my package reccomend.Anywhere that doesn't require paperwork.MELPA, I just didn't attempt to submit my packages to other repos.MELPA because i figure gnu elpa doesn’t care about my stupid little packagesMELPA allows the package owner to retain ownership, whereas GNU assumes ownership. Also dealing with emacs-devel is a nightmare.How easy it is to submit. I used melpa, would like to submit to elpa too but I feel I am still a bit unexperienced.MELPA, because it has the fewest barriers, good support, and no ideology.MELPA first, GNU ELPA once maturedI submit to popular repositories such as MELPA that are used by a lot of people.low barrier to get the package into the repo, currently it is melpa.gnu elpanull answer. "Packages" are a Windows-iter Software management method.No, they are all garbage and silly. I am not signing a bunch of legal paperwork to make software. I am not changing my code to fit some silly format for some half-baked file hosting system to figure out how to do "upload/download" operations. I don't get paid to write my code and if I did release it then I expect some form of compensation (donations are _NOT_ compensation). I'd only ever consider some kind of GitHub platform that I can self-host and require payment (probably a subscription) to use my stuff.Melpa. Low hassle but still well moderated and inspected. No complex and long paperwork.I'll submit to Melpa by default. I might consider NonGNU Elpa, but I don't know how discoverable that repo isCopyright assignment for everyone is sometimes not possible, so then I usually look into NonGNU ELPA and maybe MELPA for the code reviewMelpa, Emacsmirrordon't knowMELPA as it is the main repository that I use.I will release all code I make into the wild but I don't believe in centralized repositories built using current means of consensus. We need to solve the tragedy of the commons. Anyway, I'd make a guix channel so that people could still install my packages and updates pretty easily.I have written a package recently, bazel-mode. I will submit it to GNU ELPA, since it's GNU licensed. I would not write a non-GNU package.melpa. going gnu is too much hurdle.MELPA is the biggest, and has a great review process.MELPA, as that seemed simple at the time...Used to submit to MELPA but I dislike the rolling release style, now submit to GNU ELPA only.When people asked me toMELPA, that is what I am most familiar with.I tend to just leave them on github.ELPA if generally useful & high quality, otherwise don't submitMelpa is the easiest, so I just go there.I choose the most convenient repository that most users have access toMELPA seems to be easy to contribute to GNU ELPA is restrictiveBecause time is often my limiting factor, I go with the repository with the lowest barrier to entry.GNU ELPA, because fsf and free software advocacyMELPA, because that's what I useNotmuch elpa. Easier than elpa avail by default (melpa suspicious)org-mode,org-qlMelpa by default, as it's easy to add my package.Haven't researched the optionselpa,melpaThe easiest for me to submit to.Melpa. I chose it so others could install it easilyCommited it to MELPA because it's the only repo I aware of.GNU ELPA only, because of the GNU philosophy and community support.I inherited a packageMELPA but only because I was more familiar with itThe ones I think are of general usefulnessMELPA. There is really no point in putting stuff in ELPA.GNU ELPA, NonGNU ELPA, GitHub, GitLab, CodebergMelpa because of the low barrier to entryI maintain a package on NonGNU ELPA. In my view, NonGNU and GNU ELPA have the major advantage of being governed by the Emacs maintainers, as well as the minor advantage of being enabled by default which makes packages easier to install for users.Usually to MELPAI don't have a clue, would probably try to go with whatever I found my distribution is connected to.I've always had problems getting the FSF copyright papers signed by my company. I work for a very large multi-national corporation and find it difficult to even find the right person/people to present the paperwork to. I've tried on a couple of different attempts to find the right person and get the right permissions, but even after almost 20 years at the same company have not been successful. Thus, I tend to submit work to software that doesn't require FSF copyright assignment, due to this roadblock.Copyright requirements.Only submit to melpaNA Internal packagesI do not have the know-how to do it :(I don't like the process of contributing to elpa and (non gnu elpa), I don't like how the certain people behave and talk on Emacs mailing lists and do not wish to interact with those people and for that reason do not post to Emacs mailing lists nor do I interact with their repositories. For that sole reason, I prefer to contribute to Melpa.MELPA (well managed)I'd probably pick MELPA because that is what I already usesince I use melpa I publish package there🤷Melpa. Haven't considered other repositories yet.I submit to MELPA because it's easy and I want to be able to accept contributions from people who haven't signed the copyright papers.Prefer elpa, nongnu/melpa if not possibleEase of submittingGitHub,GNU ELPA, NonGNU ELPA, MELPANot applicableGitHub or use IPFSI will leave it on github and forego the hassle. People can use straight to use it easily anyway. I will even update the readme with straight configuration using the github url.MELPA is my unexamined assumed default if I weren’t producing a GNU package..I don't submit, I put them on my website.The one that's easiest to publish to. So far has been MELPA for me.Some combination of what is new, popular, and well-designedNot sure?Emacs-devel recommended ELPA, so that's what I did.MELPA, just githubTry GNU ELPA first.GNU ELPA because of its official statusJust MELPA because that's what most people use.no fsf, github or somewhere even more freeease of submission, widest reachAlways submit to melpaI generally don't write or make changes to packages; I make them to C code in the Emacs repository, mainly related to support for the window system I use, which I know very well.MELPA because I don’t have FSF papers yet. I didn’t know about NonGNU.My employer (a public University) created problems with my signing FSF copyright papers, so I submit to MELPA.I had packages on MELPA, but the only package I maintain now (flymake-proselint) is on GNU ELPA. I wanted it to be immediately available to Emacs users without forcing them to configure the package archives.Try to avoid anything too much GNU. NonGNU ELPA och MELPA are the only options.I start writing only for myself. If a package seems useful I put it on GitHub. If someone there asks about package repossitories, I submit to MELPA. If someone asks me specifically about GNU ELPA, then I submit there.start at MELPA, try and target ELPA laterI wrote a color theme and submitted to MELPA because NonGNU ELPA didn't exist and it was a low barrier to entryAlways MELPAMelpa, seems to be easierI have no ideaMelpa has the least barrier to entryI've written a few packages that were fairly incomplete and other people submitted them for me.don't write packageesI use only those I can controlGuix, because that is what I use.I do not submit, it is additional effort. I consider public git repo enough.Is there any other choice than MELPA ?Only MELPAIt’s been a while, but I’ve typically just gone with MELPA for the sake of simplicity.I don't submit my packages to elisp repos; I use straight.el and fetch my packages right from the git repoI just go for melpaMaybe MELPA?If it's too specific, not very well aligned with FSF or too immature: MELPA. If it was general, core to Emacs, I would try GNU ELPA.Probably MELPA, I think, because it has the easiest process if I understand things correctly.I would just put it on melpa or leave it on my GitHub.I've submitted to Melpa because it was easy. I've never thought seriously about trying to submit elsewhere, and my packages aren't at all popular.I used to have my own ELPA, but I shut it down in the springMelpa, but mostly just githubBased on the repository I use the most or the one that seems to be the most active/have the greatest distribution.I default to MELPA, that's the easiest for me to submit packages to. I don't care about spreading my package around, or building a community around them - they're for me. I publish them on my Gitea, and if someone asks me nicely, I'll submit it to MELPA. I'm not interested in doing more than that.I have never submitted a package, but I'd go for the path of least resistance. The packages I wrote for myself are so specific, maybe 10-20 people would use them, if any. For this I don't have time or interest in following any coding guidelines or signing any papers. Just use it if it works for you.I submit to NonGNU ELPA since I haven’t assigned copyright yet, and I’d prefer users of my packages to get stable versions by default.don’t write packagesI just submit it to ELPA. Low ceremony b and people who care will find it there.Never tried.I can't let people execute my code it's bad, it stays on git for information, you do you.Given that my packages are not part of Emacs, I submit them to MELPA and NonGNU ELPA.Some of my packages are on MELPA, but only because other people expressed interest in having them there. I do not take initiative in submitting my packages to any repositories before I see interest from the community e.g. through issues.MELPA because it is the easiest (for me, and contributors)I submit to melpa first. If the packages are popular, I might submit them to NonGNU ELPA.melpa is easier because it doesn't require copyright attributionThe packages I have written are on GitHub, but I haven't yet felt that any of them were worthy for inclusion on Elpa or Melpa.My long abandoned packages only ever existed on melpa.Melpa doesn't require me to sign over my software to the FSF. I retain my preferred GitHub based workflow.I would need to read on the subject.I haven't bothered to submit them to any package repositories -- some of them are in GNU Emacs anyway, but those that aren't I would submit to a package repository if I thought it would help other users.None, I expect people to use straight or quelpaCopyright issuesWhenever I do, will probably just do it on GitHubSubmitting to MALPA on github is easy. They have a build pipeline and the workflow is great. They are nice and answer fast.MELPA,githubMelpa by default, everything else is too bureaucratic.I haven't actually submitted my packages yet, but when I do, they'll (likely) all be in GNU ELPA.Melpa as it's easyIf the FSF / GNU runs a service, then I refuse to use itI have a single package that I have written, and am improving upon. In future I would like to submit it to MELPAGitHub with straighthaven't researched yet, but GNU ELPA seems likelymy git repos FSF paperwork too painful when working for large companiesI've never submitted to one.melpa, because it's the closest thing to THE ONE in my mind (aside from other straight.el who can just use a git forge)MELPA is easiest, github/gitlab are easy collaborative environments with instant feedback. I find the Elpa mailing lists are where my packages go to die. Probably I'm missing some critical factor, or, the developers there are overwhelmed.NAActually I don't knowI didn't. I just ask people to use straight.el on my github project pages.I only submit them to MELPA.Stop asking me about packages!GNU Elpa if it's interesting for enough people and should be long-lived, NonGNU Elpa to allow more contributions.MELPA since I haven't been bothered with anything elseNot GNU ELPA due to FSF paperworkGNU ELPA, as I already have assigned copyright to the FSF.I don’t decide. I just put it on melpaI dont't know.NonGnu ElpaMELPA is easy. ELPA and NonGNU elpa is more effort, so not by default.Ease/time. I don’t really have time to create or maintain the packages that I do, so the lower the barrier to submission for me the better. Hence everything is easiest with Melpa.nongnu elp, and melpaWhere related repos can be found (e.g. org)GNU ELPA. If package doesn't have all contributors with copyright assigned to FSF, then MELPAI have one package and it only lives on source hut. I don't know how to send things to melpa.GNU ELPA because it's enabled by default, and I have FSF copyright papers on file.MELPA, as it is an easy preparation to package it as a distribution packageMaintain a package - on MELPA - b/c of relative ease of entry, use of Github (yes, I know... but I am not a software professional, so having easy-to-use/access platforms matters).I don't, but I guess would to elpa/melpa because they seem the most used (I'm probably wrong about others)MELPA because I like GithubMy own packages are very special for my work.Depends on whether FSF assignment is required. I prefer NonGNU ELPA.Whatever is easiest. I'm not a GNU zealot, I'm pro-collaboration but anti-bureaucracyI have not submitted my personal packages to any repo yet, but I would be more inclined to go to MELPA, as I feel my code may not be high enough quality for GNU ELPAease of useMELPA or anything that won't require from me extra bureaucracy.If I want it to be as widely available as possible, or hold hope for it being included in Emacs one day, GNU ELPA is my choice. Other packages tend to be un-submitted, but I plan on submitting more to MELPA in due course.Yet to do :)I just put my stuff on github, haven't ever submitted to a repoI've recently published my own package to MELPA, since I thought this would be the least complicated. Still, the publication process was waay to heavy (although very helpful due to the review process) compared to develop the package in the first place. This is so far away from a simple 'npm publish' and I guess the package ecosystem would be a lot richer if the publishing would be easier.I've written a few very small packages, but haven't submitted them to any repository. If I decided to do so, I suspect I'd consider MELPA based on my understanding that it has the lowest barrier to entry.MELPA because the process is quite simple to just raise a PR on their github repo https://github.com/melpa/melpaFor now, all my published packages are published on MELPA due to how easy it is to publish packages there, although I’m considering publishing on GNU ELPA.Everything I write is available via git. I don't care if somebody else uploads my stuff to any package repositories, though won't support kludges required only for it to be installable via the package manager.MELPA only because it doesn't require FSF paperworkGitHub, MELPAshared on academic web pagemelpa doesn't require a copyright assignment.MELPA, except their style guide is extremely strict and annoying.I always go with MELPA, its relatively easy.None. Some of my customizations involve changes to the C code, and FSF pigheadedness prevents upstreaming.MELPA seems to be the most useful and popular.go for melpa, I know the processi havent researched the subject but i will probably upload it to melpaGithub with WTFPLN\AMELPA is easy and to this point has been ubiquitous; this is my default. Supply chain attacks are a real issue though, so if another repository has a better story on provenance, that would change my preference.I just leave them in my profile because sharing is such a hassleDirect to MELPA; largest repo of packages I'm aware ofEase of contribution (developer) and access (user). I've submitted a couple of small packages to MELPA, in great part because I think it has the least total barrier-to-entry and it's very widely used.Probably a repo which makes it easiest to download without additional configuration.If I write a package suitable for the public, I would just have a public GitRepo and a sample straight + use-package config.Have not created packages. If I did it would probably be melpa as it is the easiest to contribute to.
Which industry do you work in? StringSoftware DevelopmentResearchStudentFin TechHealthcareTelecomEducation servicesManufacturingCreative/WritingMedia/PublishingLegalITretiredGovernmentAerospaceEngineeringConsultingFinanceIT ConsultingUnemployedDefenseHardware DevelopmentfinanceRetiredRetailLogisticsData ScienceaerospacegovernmentPublic serviceSemiconductorInsurancereal estateCybersecuritySecurityEntertainmentPoliticsSemiconductorsunemployedArchitectureCyber SecurityNoneArtsretailUtilitiesbankingPublic sectorIndustry/ResearchSelf-employedInfoSecMiningAutomotiveHospitalityIT servicesPharmaPublic HealthGame DevelopmentNEETCyber securityRoboticsNGOVariousTransportationconstructionElectrical EngineeringAgNo work unfortunately, but aim for Education services, Software development or manufacturing (or maybe Academia/Research)cyber security intelligenceretired from IT-sales supportData EngineeringICT servicetrade union researchTech otherSocial ServicesSys engineerMusic StreamingI do not workVFXhospitalityTechnical SalesCryptoformer IT researcher, now designerFinancialAcademia/sysadmingamejoblessI use vimEngineering supportunemployed (need a job)Coffeefood :D, but soon going to soft devIT consultingretireeManagmentEngineering and Contruction; offshore and powergenerationIT relatedPhysical Access ControlBioinformatics consultingnon-profitGames, Film VFX, and AnimationHigh Techstatestay at home dadPublic SectorInternet Service ProviderFormer academic (biomedical) and software dev, current stay-at-home parentMunicipal waterworksAviationDog TrainerSofware Development in EducationOut of workLabourRetail ITHousewifeFilm/TVInformation TechnologyInvestmentInformation securityGISSystem AdministratorneetHuman resource servicesTech support and repairsLaw EnforcementBusiness operationsNaval Ship DesignData scienceOnline retailIT ConsultancyCommerceI don'tAutomobilebusinessgovernment/regulatoryBanking, risk model developer (not IT)EduTechspace researchAerospace/ DefenseEntertainment/Video GamesProfessional servicesfintech; mobile development; startupsFood serviceField service technicianmusic, programmingGovt labPart-time manual labourASIC/SoC designMarketingintelligent transportation systemNot-for-profitIT services (sysadmin)JoblessRailway LogisticsManagement ConsultingSocialnoneIT securityAlgorithm weþhigh school studentAcademiaRetired software developerASIC designspaceIndustrial researchFinancial servicesTranslationConsumer ProductsCultureIT/Project ManagementWebhostinglogisticsAgricultureIT Training / ConsultingAcoustics EngineeringProstitutionLive entertainment designBrewingr&d/Industrial automationAcademia, publishing, art. Why is this a radio button choice?DataStartup companyEngineering (aerospace)Commercial Health ScienceGamingTechnology ConsultingI plan to either get a job in CS or photography.government officiallegal, writing and software developmentVertical IT servicescyber securityA mixture of Software Development and InfoSec ResearchPrintingFinance (not FinTech)IoTIT Operationsnull answer (Pensioner)Buildingcomputer repairAeeospacei don't work yetVarious, now retired working on personal projectsretired science researcherAcademia (Student) AND Software DevelopmentMutual aidPublic administrationApplication SecurityDeveloper ExperienceBiotechE commerceHa, governmentwarehouseQuantum computingBanking and Financeic designShippingNavy PilotSecurity GuardFirmware DevelopmentMathematical Consultinghome appliance repairsGeomaticsBiotech and machine learningBiotechnologyTech FounderHardware developmentLooking actively for a job T.T in Software Development mostlyProfessional Services/ManagementCloud ProviderRailway (formal methods)Creative/Writing,Software DevelopmentBlockchainCoaching / counseling / Content creationHostingaeronautical engineeringgeneral IT servicesProperty ManagementRetired!PizzaioloGovernment/Public SectorTechbroadcast mediaInformation SecurityChristian pastorAlgorithmic tradingGovernment/Civil EngineeringI'm literally in high school.Quant TradingVenture CapitalBusiness Support ServicesPrecision EngineeringTransportBio techMedicalOil&GasLocal gov (non-technical role)CG/FX/Motion PicturesEntertainment (broadcast)Industry ResearchNon-profitanimal farmingbig datadata analyst\researcher in fraud prevention companyTech retailNFPCloud infrastructureNow retired, formerly in website operations and Linux server adminretired academiaMicroelectronicsConstruction, real estateIndustrial systems (including embedded software)Music & Sound EngineeringCharityMilitaryCybersecurity Consultantsecurityorganizational consultingAI - computer visionEngineering (not software)Public ServiceWork on all of academia/research, IT technician and web development.farmer soonIT, some sw devEngineering consultingIntralogisticsGame industryRenewable energyTourismcontractingLibrarianship (Public)Energyconstruction - facilty managementIC DesignIllustration,animation, creative writingAllrounder, Educator, Trainer, SysadminRetired (was Software Development)SpacelotteryTechnology / InfrastructureCivil EngineeringdefensePrivacy tech entrepreneurCloud servicesIT SupportEntertainment (technician)BaristaOil & GasENgineering and constructionmaritime transportationClient ServiceCivil engineeringQuantitative FinanceData analyticsContract engineeringMuseumCustomer ServicedisabledBanking"between positions"GovernmentalStay-at-home parentCloudDevelopment and climate change resiliencemusicHardware, chip designweb hostinge-commerceSchool studentEnvironmental MonitoringSemi-retiredembeddedHealthcare/InsuranceSemiconductor IPIntergrated CircuitField ITFirmwareSoftware Development and Academia (Student)Local governmentVideo GamesMultiple: Fin Techs, Software Development, Operating SystemsIT StartupCivil engineering / constructionUtility LocatingOtherindustry computer researchPropertyTransportation/GovernmentElectronics DesignInfromation SecuritySemiconductor developmentNative American TribeTechnical Safety Organisationinternet governanceRetired (but was software development)energyUrban planningTechnologyConventional IndustryhostingConsulting EngineeringAcademic administrationUnable to workPublic servicesIT technician at the Superior Court of Justice (Brazil)International organizationsTravelHealthcare and software developmentEmbedded DevelopmentHardware architectureI do not work. I go to school(I don't know if the right answer is academia but I wrote this cause it's easier).IT/sysadminReal Estate/Construction
Which features motivated you to initially try Emacs? Vector{String}Text editing featuresExtensibilityPackage(s)Part of the GNU project / FSFCommunityorg-modeOrg modeorg modeOrg-modeLisporgmodeSLIMEOrgmodeOrg ModeCuriosityOrgcuriosityelispOrg-ModelisporgClojureslimeorg-roamAuctexgnusmagitSlimeCommon Lispevil-modeMagitDoom EmacsGnusSpacemacskeyboard macrosEvilAUCTeXdon't rememberLisp supportCIDERHistoryevilCoolnessLearning Common LispElispEmacs Lisporg-babelLISPDoomNoneRequired for workCustomizabilityprogrammabilityGNUSOrgModeCommon Lisp Integrationmultiplatformmemesgdb integrationCiderWorkOne editor for everythingGDB integrationhistoryEmacspeakit was the most advancedn/aIt felt different enough, I hoped the good ideas could be uncovered thereI was writing Lisp codeExomindNote takinguser friendlinessI got frustrated with how byzantine vim seemed and wanted an editor where I could do modal editing with easier config/extensionAvailability on Uni computersEvil mode and org modeCIDER package for ClojureUsing a Lisp for configuration and extensibilityIt was the editor for Solaris C at the timeStarted with goslings emacsa youtube video probablyIt was required for a classCuriosity and a certain dissatisfaction with other text editors.Didn’t want to learn VimscriptText mode via SSHdemonsThe development environment was built on top of EmacsTrampLanguage support (Common Lisp)funAnnoyed by vim+vscodeemacs-calfw packageMoving to GNU/Linux OSnicer terminal experienceAlternative text editorsall my cool MIT friends used itthat's what everyone used in our CS departmentDocumentation and lispBuilt In features, vim never clicked, netbeans was clunky. actual C-modeLISP developmentIt wasn't vi.Convenient that it had a GUI, and convenient that it was not viml33t peer pressureI could search for commands available and not have to guess what :%s/find/replace/g was doingat the time I was starting to get into clojureThe other cool coders where using it^^tool integration, GDB first, then diredvi-keybindings with full customizationMystique auraExternal adviceI wanted to play around in lispslisp interaction, org, magitIntegration with workplace toolingGreat support for Common Lisp (SLIME)SLY / SLIME for Common Lisp programmingArticle I read on the power of org-modeRequirement for university project! Only editor installedThe holy wars- to see if I liked it better than Vimclojure and orghad issues with vim/neovimMy interest in lispPerformance compared to electron based editorsMagit :)good repl for python and schemethe ability to live reload my environmentTo truly understand the Vim vs Emacs warTRAMPSchool used for scheme.CMUCL REPL integrationlack of choicelongevityThe legends surrounding it; ClojureRequired for classI had never had an advanced vimrc and before starting to configure it, I asked myself: Do I want to learn vimscript or a lisp. The answer came easy to me.Lisp editing supportInvestigation of the classic editor flame warCommon lisp and lisps in generalnone-Fast workingSLIME for common lispIts nature as Lisp runtimeMy professor made melearning one tool for many purpose4coder is no longer activeAucTeXcross platformvi alternative with less crazy keybindingsLongevity of the projectundo in region, visual undo tree,Editor that works via ssh (i.e. Terminal UI); more featureful editor than Notepad++Elisp > VimLNerds on 4chan said it was goodDidn't really think about it. I just started using it because a coworker used it.Scheme supportWeirdly, I can't rememberwas forced to initiallyHacker cultureIts Lisp IDEnon-modal key-bindingsFree Software, no vendor lock inOrg Mode, Magitnon-modal keys - as opossed to viKey-bindingsopened by accidentlisp developmentIt's religious that hackers know Emacs.Org-mode, SLIMEIt is the best Lisp IDELean memory usagebeing able to run a shell inside the editor (coming from vim, I had to context switch between editing and running stuff in the shell)Basically needed to program in Common LispText based, free software, in the "Packages" checkbox it was Org and AUCTeXwas upset with other softwareUbiquityThere was no good editor available. Kate, Bluefish, etc, they all were horrible.Using not too much RAM, by modern standardsIt was just the default choice at a research internship I did when I was youngCompilation mode.Latex rendering / org modetime keeping in OrgspeedI was learning R and this was before RStudiogood help systemEmacs configuration distributions (Doom Emacs, Spacemacs)No featurs, was the recommendation during my first internship.pdf-toolsImpulsivness and loreMentors I trusted had it as their tool of choicecomination of wanting to learn lisp and wanting a simpler (bwahaha) prose writing programThe impressive coders were using itTime-tracking via org-modeIt was there.I love being able to set things up based on a certain combination of keys - it works well for me. My fingers easily adopt new muscle memory, I can type very rapidly and precisely, and it's nice to have control over minute things.hated viXah Fly Keys's efficient cursor navigation and editing. It being far better than Vim.latex editing with auctexdoom emacsQWANgithub independent (elpa)availability, and couldn't get the hang of vino-ui, clean screenI had to for workpart of GNU/Linux and better than VimClojure/CiderOfficial interface to GDB and SchemePeople saying it was the bee's kneesClojure packagesLimitations of vi (not vim)in college we were given a cheatsheet for vim/emacs; emacs seemed to click with me betterI tried it like i tried many others beforeTerminal supportneeded for jobavailable on multiple flavors of UnixClojure developmentalternative to VIIt was the standard editor at CollegeProgramming languages supportNo choice, it was the default editor in my Schoolciderwindows, kill ringmmm-modeEmacs Speaks StatisticsLaTeX writinglisp editorSomeone detailed how they can write Latex really quickly using vim, then I read comparisons between vim and emacs and came down on emacs.Work colleaguesIt was either Emacs or some stupid vi variant on a SunOS serverEverything else is awful and Visual Studio 2017 is not available on macOS and Notepad++ is still Windows ONLY (the day that comes to MacOS I am leaving Emacs)It was basically the only choice besides vigames, IDE(very important), entertainment,Keybindingssyntax coloringdisliked modal editingInstalled on the systemaquamacsorg-mode and availability of vim mode (evil)Full keyboard controllableI had heard Vim and Emacs. So I tried Vim and it didn't made sense. So I gave Emacs a try.Legendary status in the hacker community.asyncIt was suggested as a good way to run R.Easily open many files, compared to VimSpacemacs: It looked like a fully tricked out Vim config with less maintenance required than my then Vim setup (how wrong I was about the less tinkering part...)L33TnessMy prof said to use it for editing on the Sun workstations.Data science dept at my uni.Literate programmingsome of the world's best hackers use itEstablished for decades and will be here for decadesI was a Vim user but get tired of VimL and decided to try this "Best OS which has everything except a good text editor" thingy.Built on a Lisp dialectLooked prettymu4eInferior shellsI got conviced during vim/emacs debateESS package for RDiscoverabilityCommon lisp, with slime/sly was highly recommendCross platform, GUI & terminalwas forced to by Robert Dondero, Jr. for a class at universityHistory/venerabilityWas trying out editors until I found something that I likedspecifically SLIMELanguage integration (haskell)Promise of integration with all my workflowsOrg-mode Showcaselearning about lisp and lisp machinesit was there, and people were using it (this was Unipress Emacs)I was interested in this historically significant editorOrg modUniversity mandated itRequired by first job (internship).The CS professor was using itMy dad says coolest hackers use EmacsStabilityCan’t rememberOrg for knowledge managementprogramming supportVideo playerUniversity machine had it installedIt's part of the open source canon, same as Vim.org/org-roam/evilMostly I'd heard that it'd be good for editing Python code, but I'd also heard rumors it was a good OS, so that also made me curious.In college programming class, I was introduced to emacs and vi at the same time, and told "pick one". Emacs felt most comfortable.Had to choose between Emacs and Vihaskell supportIIRC TeX support and M-x shellThe integrated Perl debugger (which I haven’t used in 20 years, but was the killer feature that got me to try emacs.)Just wanted to see how it compares with VIMOnly available GUI editor in Linux back in mid-90sNeeded to use Emacspeak package. Not a choice, only viable option at the time.sly/slimetrampClojure software development tooling (in 2011)easier than vievil-mode. viper etc. never seemed good enough but evil-mode made me consider it seriouslyFamous people like Paul Graham, Stallman, Guy Steele use Emacs. No famous people use VIM :Porg/magitWriting in LaTeXReddit emacs pornPeople who use it are great personsIntegrated frames/text editor/shell-modeOrg mode was the major selling point for mewas told "use this it's the hacker's editor"Looking for a better vim integrationfirst time was '88 or so. I don't really recall.Existing for so many yearsBest development environment for Common LispRtL text supportI thought that many Hackers use EmacsMy intro to AI class instructor strongly recommended it.I was asked to work with itAt the time (2013) Emacs had the best language support for more esoteric languagesVM couldn't support my usualPower and flexibility.Cool features landing in other editors always seemed to start as Emacs packages.It was "the other" editor.Coding LispCommon Lisp environmentPreinstalled in MacOSNeed an editor that was not vi and could be used on different flavors of Unix, Windows, and OS/2Just choosing an editor when starting my Linux journey : only vi and emacs were mentionned in my first CD leafletcalfw package and org-modePlain text systemkeybindingsHeard it was great.font antialiasing (long time ago)Needed free software note taking application and found Emacs + Org-mode + Evil.Also knowing that evil mode was good, proven and stableDoctor modeCode highlighting for SchemeTUI editing programFriendCloutbetter LSP supportTired of vimscriptTech support :) from a friend, and on the command line it was either emacs or vi, and I found emacs less traumatizingIt was thereusing scheme/lisp/clojureConfigured by a "real language" that isn't vimscript :)Open source IDEuniversity classHoward AbramsBetter syntax highlighting supportSorry, can't remember.Todo management (org agenda)Colleague recommendationOpen source text editor. Future ProofMP3 player, IRC client, was less of a finger-twister than vim on keyboard layout I was using at the timeTRAMP!ledger-modeEverybody used Vim around mefuture-proof editorThe challenge to try something newModesEvil-mode, being an editor that all vim can doIt looked nerdy (I was a teenager).Cost nothing, and people kept recommending it.integrated lisp interpreterCollege ran out of VI handouts..... ;-)So that I can be differentnone, persuaded by friendIt was required at university, and the default editor in the computer science dept.Used in an architecture classConfiguration/extension in lispWant have a cool IDE setupPretty much the default option then.Wasn't motivated, just started using what was recommended.Language Support (Clojure)Org-Mode, Magitnot having to use the mouseSplitting WindowsORG MODE + Customisation capabilitiesThe myths and legends (seriously)Recommended by mentorcalendar packageWanted to learn lisp and have a an editor that supported it wellorgmode - Aaron Bieber talkLanguage supportto code in common lispdiscovering lisp stuffI didn't know Visual Studio Code existedCurious about LispOne professor mentioned it but said it has a tight learning curve as it's keyboard-driven. I saw that as a challenge. Also it seemed very nerdy which I liked.other side of editor warorg-mode and ability to use slimeusing ESS and RI hate viIt was the tool of choice at the company where I workedX Windows supportCommon Lisp (SLIME) SupportUnderstand why people pit Emacs vs VimHated VimScriptSupport for lisp/scheme editingIt was installedFOSSHaving one editor for the rest of my lifegot into dll-hell with vimSLIME (for Common Lisp), Availability on Windows (necessary for work)Seemed to be the most powerful editorEXWM - being able to use it as my window manager was the main feature.Mentor at my first job told me it was the bestvery hard recommendation from a professor I respectedI can't rememberNotmuch email clientwanted to graduate to a "real" editorworks in terminalhistoric curiosityeveryone is so enthusiasticBetter than viEvil modeSupport for programmingdoom; because it gave me a setup very close to what I already had with vim, but emacs offered more.Wanting to try something elseFriend showed me amazing features and I wanted *that*lisp bgslime (superior lisp interaction mode)I started to experience wrist pain, and was looking for an editor I could use completely without the mousefree as in beer; comint shell feature; diredback then it was the only full screengraphics and evilI was looking for a replacement or VimWiki and found org-mode very compellingEmacs has best support for lisp. I could not figure out how to do lisp in vim.at that time Emacs had the best source code highlightingSupports Ada languageJust curiousHeard it was coolAmazing programming workflowsFrustration with VimScriptAgda modemultiple buffers on VT terminalI read "Vim and Emacs are the most powerful text editors" and after testing the tutorial in both I stuck with Emacs because it was easier to understand.Xemacs (Sun) C debugInitially I used it as very powerful search and replace (regexp)Just looks coolasked by my teaching assistantI use vimPython IDE (Projectile)seeing other experienced Emacs users doing magicmouse avoidanceGreen colorindentation of C code!Vim/Vi modes, I felt I was always in the wrong mode until I said "Fuck it, I'm installing Emacs"Ability to use vim bindings with plain text filesIts keyboardcentrism. I can't stand the mouseorg-mode and vs-code replacementLots of Clojure people use itneeded something for schemerecommended by bossbeing an "historic" editorThere was a time where Emacs was almost always the first editor that gets a syntax highlighting package for esoteric languagesAcademic interestIt was simpler than vipraise for org-mode onlineIt was the main editor available on the system I used back thenWanted to be a "hacker"libreI knew how to quitOrg-mode was the killer appI didn't know other editors for unix OSOrg Mode and Markdown Modecompare to vimrecommended for clojureDon't remember, sry.Heard good things about org mode for life management; data all on my own computer and not behind a paywallESS (Emacs Speaks Statistics) and AucTeXlatex editingMy own curiosityit is great for Common Lisp software developmentREPL support (vim didn't have it)Program in Lispit was coolWas looking for a way to execute SQL from a text editor buffer. Never looked backMy colleague's strong recommendationPeople around me seemed to like it a lotLisp editing capabilitiesMore features than other editorsEmacs users seem to be more geek-ishgdb integration was convenientIn 1983, Emacs could edit multiple buffers in different windows. Nothing else did.It's libreWizardyLisp editing capabilities (I had a lisp job)Common Lisp/SlimeHad to edit files in un*x systemsThe fact that it could render text with proportional fontsMy TA said I had to.Lisp as a configuration language sounded coolHistorial InterestEntirely Keyboard DrivenIt was the editor in use at schoolKnowledge of it as an inspiration for previously used editors.Hard to say as everyone used it at our University so either just it was what I knew or I had a friend who really loved it and that feeling of "being on the same team" kind of kept me going, maybe; I guess that's kind of community but I'm not sure if that's it or not so putting this under Other.Fewer external language dependencies compared to VimSpecifically the VHDL packageasdfDOOM promised a fast, curated "batteries included" experience, using modal editing.I couldn't make heads or tails of Vim.Nothing in particular. It was just another editor to tryreputationOnly one available.TUI-like GUIUnlike Vim, it doesn't feel like it is fighting against being extended.doomemacs, magitorg-mode, magitHaving a gui (unlike vim)Better extension languageParedit, SLIMEOnly non modal editor availableRequired for Scheme classClojure supportMy initial motivation was I needed a free text editor that could open a 64Meg text file on Windows NT. There weren't many free options at that time in the 90s.Good support for HaskellAvailable on the command lineVS code bricked my machinekeybindBeing introducedI started by trying doom and got me hooked.Terminal editingLaTeXubiquityUsing the Usenet with GnusOrg mode time trackingnotmuchProgramabillity in Lispline editors suckedClojure language supportSuggested as part of a college courseEvery interaction is a real lisp function you can call in codespacemacs evil modeI already knew some Vi and didn't care for it. So trying Emacs seemed like a worthwhile experiment.working with a lisp replDurability (get good at something that will be around long term)graphics and responsivenessDisliked viIt was the default on my department machineFree and Open Source, Fast, LightweightWas basically told I had to use itFriend recommended it for C++writing agdaI mistakenly thought Emacs was related to macOS.It was not viSeeing a coworker that was very efficient using it.Proof general/CoqIt was taught at my universityMy PhD advisor just told me "here, this is emacs, you edit programs with it", just as if it were a "normal" editorBest unix editor at the time. Stable, therefor good long term investmentmultiple windows in ttyCuriosity and programming environmentThere was no other choice at this timePackages for ClojureI found it easier to use than vi.being coolCommon Lisp support via SLIMEIt looked coolOrg mode for outlining proseSLIME (but I don't code in Common Lisp anymore)It was not vim yet still used by hackersjob requirementI was interested in the easter eggs in middle school, then just kinda appreciated the Swiss Army knife potential of the entire thingRMSMacrosForced by courseKeyboard focusI wanted to try Lisp, and Emacs is the editor for thatvi's modal nature irritated meSimplicity and completeness out of the boxKiller features like Org, idea of doing every computing task through one interfaceRun lispI wanted to manage a config in something other than vimscript or jsonStallmanRecommendation by an instructorIt looked cool, and I've heard the things it is able to do.LaTeX, since Teco (author of a VSCode plugin) had moved from VSCode to emacsonly editor to choose fromhilit19... this was 1995.Good support for lispCuriosity to use an old venerable piece of software. Also ElispThe alternative editors on the CDC Cyber I was using were unimaginably worsehacker prestigeLisp languages supportI don't rememberpretty formattingIt "becomes" your OS in a sense.versatility and Org modeVariable fonts and why notForced to due to work requirementsorg roamgeneral reputationmoved to LinuxMy professor told me that I could take it as a challenge15 years ago, it was one of the two editors allowed at the informatics olympiads.clojure cider packageI wanted to learn programming and to have something to constantly expiriment with.Atom got discontinuedI was looking for a good editor for programming. I also tried vi (which I can still get around in)Lisp programmingBest editor for OCamlSLIME package for lispTried vi, it didn't agree with mePerformancethe ability to have two windows side by sidelegendsMinimalismI worked with a friend who build a simulator within emacs. It was amazing. I was sold instantly.spacemacsorg-mode, to publish a research paperJulia editorGood Support for LispCIDER clojure developmentA math class required students to write a paper using LaTeX in emacs.TraditionLike vim but graphics and nice fontsCuriosity about Lispevil modeevil-mode & org-modeEmacs was the only reasonable choice back in the 1980s.It was the standard editor at workfancy UICan not rememberI had no idea what to choose, I picked the same as my colleaguesI was told only noobs used AtomIt was far more powerful than vi at the time"Soft requirement" for an internship at a university lab.M-x dissociated-pressAuto indentingIt doesn't have VIM bindings by defaultBetter ergonomics than Notepad++sgml modeLimitations of ViWorking on multple operating systems, including very old hardware (implying it would be future proof as well).When I realized that it uses some common keybinds with readlineI was learning Clojure and it was suggested as a good default editorI was told it was better than vimIt was described as "the editor you use on Unix" when I got into UnixWhen I tried out clojure firs timeNerd factorIt's what the cool kids usedI started using Emacs for sing org-mode.slime / clLongevity, I wanted to learn something that would be with me for the rest of my careerIt was taught to every CMU undergraduate at the timeNota organizationorganizational featuresmouselessnessAvailable on WindowsSuperior handling of multiple buffers.support for writing in foreign languagesFiguring out what the fuzz about Doom Emacs was all aboutNavigational keybinding habitIDE capabilitiesIt existedExtended in a lispLongevityThought it was coolThe fact that I could use variable-width fonts inside the editorRemote editing via TRAMPspacemacs keybinding systemWorking on a Lisp projectorg-mode, I was looking for an outliner to use for my GTD system on.Best lisp editorOrg-mode, YouTube videosAvailability on any hostAt first due to university. Then because I wanted to learn one editor really well instead of using many different editors.There were little other editors for NEXTSTEPNot Vimit was required to use in the student computer labsomething completely other then what I've known about software and software communityWanted to learn clojureI knew emacs was powerfull and it worked with many languges over many platforms and had been around for a long time. "Learn on editor and learn it well". One editor to last a life timeuniverity requirementGood support for LispOrg-mode, Magitto follow 'clojure for the brave'One-stop computing environmentInsistance of a mentorChoice was NEdit, Vi or Emacs. Emacs was slitghtly easier to get inot than Vithe excellent help system (C-h ?)Was available and I did not want to learn vi.Default editor for mail client!frustration from vimIt looked cool and stableSpacemacs keybindingsNot VIMI was going to be programming for a carreer, I figured I needed to learn a professional editor.I was in a coding bootcamp and the teachers encouraged us to use Vim. I found the keybindings and modes too confusing so I gave Emacs a try and never looked backThe Elisp languageAlternative to VSSeemed easier than vimDOOOOOOOOM (seriously I tried it because of doom emacs)I really looked up to friend who got me into it, since he seemed to know so much about GNU/Linux historyOrg-mode, CFEngineMy love for GNU LunixNotmuchit did what I neededit was the main option in the early days of clojureit had better tutorial than vimProof Generalit was used by my thesis supervisorThe reputationCarsten Dominik org-mode talkClojure toolslearning common lispFirst learned edwin, then switched to emacs after switching to a new language from SchemedocumentationThe ability to get the best Clojure experienceCliconvenient keyboard editing as vim, with mouse and GUI supportEvil mode & org-modeCommon Lisp supportI needed it for Agda; stayed for everything else.DE Knuthorg-mode tablesmodes for nearly every languageStill being maintainedhacker feelRecommended editor in introductory computer science course at universityalmost unque solution in SunOSlooking for best way of editing LaTeX (AUCTeX)RMS was heavily involved and when I was 15 that was all the endorsment I needed. That's not quite enough these days, but hey, it got me started.Heard it was a good editor for haskell (haskell-mode)Suppor for vim keybindings and functionalityGUI IntegrationMore minimal than VS CodeIt's a native programNone. It was required for work.Org mode and magitsounded like a solid optionOriginally I had to use on on a school projectprivacyThe Proof General plugin for interacting with Coqall keyboard drivenI needed it for proof assistants at university.CoolI can’t recall…that it is keyboard centricIt was described as a powerful editor, which made me curious.I had no other option actuallyEVILbesides vim, it was the only editor available on all Unix machines at universityI wanted to participate in 'editors war'Was already installed on the labs machinesIt was the only non modal editor (ie not vi)Key bindingPeople said that accessibility for blind users was much better using Emacspeak than other editors.org-mdoeThe mystical allure of Emacssetting up your own ideevil mode and org modehobbyTo learn lispDesire to learn and write lispI thought I had no choice. They gave me Emacs and told me that's what there was.Robust macros and regexClojure CIDERSeeing what other people could doSpecifically: org-roamKeyboard/Text-CentricThe smartest engineer I know recommended itShellThe computer science department expected us to use Emacs or XEmacs.Was told toCoqWriting common lispUnparalleled Lisp supportneeded an editor that workedSlickedit is very badeasier to quit than viVimscript was terrible. Then Vim guy started touting a new version of Vim script nobody wanted and I realized he was out to lunch. Neovim hadn’t yet reached 5.0 and all the cool stuff I wanted would have to wait until 5.0. So I decided to give Emacs a whirl and if i didn’t like it maybe NeoVim would have a stable 5.0 by then.LSPObservation of a colleague who was extremely productiveFreedomExcellent support for Clojure and Lisps in generalESSSomeone say it is greatI wanted a keyboard based snappy, organized notetaking system and nothing can do this better than emacs for meLisp EditingKeyboard centricavailabilityBecause vim seemed even more useless to the uninitiated ;)Initially, I was looking for a good program to create lesson notes in. I didn't want vendor lock in. Text files seemed like the most future proof. Org mode is amazing.Diredeasiest scheme and c++ text editing *indenting* ever (no j/k)I thought Spacemacs mode line looked cool.Editing LaTeXOn the package/install CD for the linux distro i was using,everybody else used vimWhen I started using Linux, emacs and vim were presented to me as THE two text editors, and I didn't like vi-style editing back then.Flipped a coin vs vimIntegration of an OCaml toplevelAir of esotericLisp InterpreterEmacs's keybindings for moving the cursorFree SoftwareSlime/SlyIt was a new shiny pennylisp, stability, longevity, low resource usage compared to featuresIt was the default text editor on the new linux machines in my grad school.Some Sensible defaults compared to vim and using a sane configuration languageLaTeX editing and viewingMore accessible than viDev environment was inside a container on a user server, so I was forced to use a TUI editor. chose emacs because I like lisp.There was no other optionsBeing lightweight (i have a super potato laptop)was only GUI editor any good on SGI and worked on VT100 terminal too!I heard Emacs is coolLatex editingRecommended editor in University elementary Scheme course. Reputation of being an editor for the professionals.Following the example of my thesis supervisorOrg-mode, Magit, maybe Org-Roam laterMy university offered Emacs and vim on their systems, and vim confused me too much at the time.Required to complete SICPelisp as kind of lispPresented as the editor to use for a classLISP loveProgrammabilityText faces customization and outline organization
How do you run Emacs? Vector{String}GUIdaemonTUI
How often do you use Magit? StringFrequentlyNeverSometimesOftenRarely
How many years have you been using Emacs for? Integer1235104620157825012301422119181327231632352817212426194029373431333938423645444143-1461013000-3991984
Do you use a starter kit/configuration framework? Stringmaximal vanillaminimal vanillaDoom EmacsSpacemacsPreludePurcellpurcellAquamacsCentaur Emacscentaur emacsPortacleemfyCrafted Emacscentaurcrafted emacsEmfyoriginally emacs-starter-kit, now heavily modified and slowly going awayn/aLambda-emacsI use one they made at workWhere is the line between light and extensive?i dont use emacsRadianWakib - Emacs for the rest of ushttps://github.com/purcell/emacs.dPortacle (an IDE for Common Lisp)Somewhere between extensive and light I'd saylittle part of spacemacsRigpalightly configed vanilla and spacemacsWhat?lightly configured, based in Linux From ScratchI haven't changed any settings.edi am one of maybe a dozen users of https://github.com/jackrusher/dotemacsmostly copied from system crafters' "from scratch"portacleI use vimIn between vanilla and fully customizedKeeps changing with work environmentxah emacsI have a much hacked, piecemeal configemacs-personalidkI cribbed off a config my friend had and then modified it as needed. They're now very divergent..emacs = 100 SLOCCentaur emacsNo, I use a moderately configured vanilla Emacs, after repeatedly trying Spacemacs but finding it confusing (seeming to lack vanilla Emacs's great integrated documentation system) and fragile (its extensive custom keymaps often seemed to get unbound for no apparent reason)Spacemacs, moving to vanillaCentaur, Doom Emacs, vanilaOver the decades my configuration has acquired lots of cruft.psimacsVincent Goulet's versiongrossDoom + a lot of custom stuffNo, but I have a lot of custom scripts/snippets. I mostly stay close to vanilla package configs so I'm not sure if this counts as "extensive, fully-custom" configuration, but it's a few hundred lines' worth of elisp stuff so...emacs-groundupstsremcrafters emacs from scratchcraftedonjcs-emacsMoved to Doom from xtensive, fully-custom configurationnano-emacsSteve Purcell'slightweight but custom configurationasdfdoom at work, personal at homeCastlemacs on Mac, vanilla on BSDSpacemacs and Vanilla on different machinespurcell's emacs.drde with extensive literate configpurcelllXah Fly keys, Xah's packages and modesDoom Emacs, but steadly migrating to my own perfomance and security optimized Emacs configuration, which would be easier if Emacs implemented them by default (look at Doom Emacs optimizations) and a better, deterministic package managerradiantVincent Gouletmy ownI use neovimExtensive packages, light configurationemacs4cl + my own confighttps://github.com/corgi-emacs/Aquamacs defaultsystemcraftersvincent gouletcrafted-emacsFrontmacsNanoel-getunsure, not in use very oftenYukimacsmany packagesPurcell'sHeavily modified corgi emacsCrafted Emacs (formerly known as rational Emacs)I do use Vimemacs from scratch youtubeDoom Emacs with a lot of customisationRougier's dotemacsCorgihttps://github.com/flyingmachine/emacs-for-clojure/I started from vanilla Emacs, built my own settings for years. Lost my confs. Used Centaur for a year. Then, I tried spacemacs.I have a custome and doooooooooooooooooom configfrom protesilaos configNoCENTAUR EMACSevil-modeI used doom but will convert to fully custom soonrdeCentuarpurcell/emacs.dpurcell's + some custom configlightly configured based on Sytem Crafters Emacs from Scratchnative-compmostly vanila emacs with many packages
Do you contribute financially to members of the Emacs community? StringNoCannotI have in the pastYesI would like toNot yetWould, but I haven't investigated howI will some dayI intend toI would like to, but currently don'Not yet.I would like to know moreI willI really should.Doom emacs donation should be simpler, like Internet Archive.No, but should get around to supporting magit and doom at some point.Our company funds & publishes some custom Emacs Lisp development.paid for Beorg on the app store?I intend to do soI would like to, did not know it was an optionI shouldNot sure if FSF counts as part of "Emacs community" - see previous answer.I use vimI would like to in the near futureMagit donationI may in the futureI would like to in 2022I would to through Liberapay, but it is not an appropriate time for me nowNo, but I probably should. Feeling guilty now.Gee, I’ll do that when I have an incomeI might want tobitcoin onlyI've not so far, but I will with my first paycheckI didn’t know people did thisHave not thought about it yet, am not opposed to itI would like to, but there's no easy way to know which packages to support - would be extremely keen to donate to emacs development if there was someone to take the cash and distribute it appropriatelyI would but don't know howI'd like toNo, but I would like to in the futureI would like to, but I don't know howI want to donate to Xah Leemaybe soonI would if there were a trustworthy mechanism to fund the ecosystem at large instead of having to do my own diligenceplanning toI have purchased/donated to Aquamacs since that's what I use at work all day every dayno, but bc currently I have no money, but in past I donated open-source projects and if I get work I'll certainly donate some emacs packagesnot yet, but willI would like to, but don't know howMake it easyhow and who?I plan to in the futureI am planning toI’ve been considering itI support FSFEi would like toFSFTim owes me 15 bucksI plan to soonYou joking?Doom Emacs via GitHubWait 'til I get my money right, then you can't tell me nothing, right? (this means I would contribute if I had $$$)no, but I shouldI would like to, but wasn't aware of anyone taking donations.Brave (BAT)Never thought about. I probably shouldwho would be best?
Do you have any general feedback on the survey? StringNoThank you!noThanks!NopeGood job!No.NoneKeep up the good workThank you for doing this!thanks!Too many mandatory questionsNope.Thank you TEC!ThanksNice job!it's fineKeep up the good work :)Thank you for your work.Thank you for doing it!thanks for doing thisKeep up the good work!Well done!Thanks for running it!Many questions such as "How do you contact package maintainers" are required, but don't include an option for "I don't contact package maintainers"Well, maybe could scan my configuration to pre-populate ... but then again, this is fine as long as the set of answers doesn't get out of hand.There were mandatory answers where none of the options applied. There needs to be a "I dont' want to answer/I don't know/N/A" option for every question.n/anullI hope I have helped. Emacs in general is not known outside the techy community. Shame. I have found it fantastic as a general tool for knowledge, task, time management etc<3 uyeah, scrap it.Ergonomic, no issues at allThanks for running this survey despite RMS's and other's on emacs-devel opinions that surveys are somehow not useful or should not be used to help inform decisions. Also kudos on the custom survey framework!Accept float value in "years since using emacs " . I have been using it since five months onlySome mandatory answers shouldn't have been. Eg regarding how you find new packages.Too longI like it. Feels snappy, just like all software shouldtoo long too many questionsGreat Job! Love Emacs, Love GNU!I think some of the questions had assumptions which did not apply to me. Fortunately they had ‘Other’ option so I could answer them without adding noise.Mildly annoyed that I cannot report still using TECO emacs or zmacs.there were a few mandatory fields where "I don't / NA" choices weren't availableMissing N/A choicesI always thought enabling ido-mode by default in plain emacs would be an improvement. The original find-file is a little choppy, especially for a newcommer, and ido-mode might be an easy way to make plain emacs feel more fluid.I think it is very important that these kinds of surveys happen, as it is essential for community feedback; especially for programs like Emacs. Keep up the great work!Maybe add a question about desktop environmentsLooking forward to seeing the results, thanks for all the hard work putting this together :)Kind of dull graphical designSome of the questions like how do you contact maintainers should’ve had an option of “I don’t” or been something like “thinking back to the last time you contacted a maintainer…”Keep doing surveys! :)Glad to see it! Hope it provides useful data.Perhaps include an option regarding the FSF copyright papers to the effect of "I have no idea what these are." A quick web search of the terms did not reveal anything besides a new paperless option for copyright assignments.where will the results be published?Some of the questions weren't relevant, but I could not leave them blank. Perhaps a 'NA' tickbox could be useful.Please put navigation buttons also at the top of the page, it would be easier to navigate back and forth.In some options there was no option like a generic "package's git forge", I could only pick Github. Although Github does dominate open source and elisp repositories, there is a minority of authors who use sourcehut or codeberg or self-hosted etc, that are just, in the survey, unfairly stamped out under "Github". In the survey results only mentioning Github may seem like endorsement, and will further solidify the perception that Github is the only home for open source software, which I think is harmful. Page 6 has a framing that implies a tradeoff, where Freedom must possibly come, specifically, at a lack of features. I know what you mean, I will not cripple my computer with non-free drivers, but more often the tradeoff of Free Software is the geekiness necessary to use it. You could have less options about the degree of the tradeoff, instead perhaps have options about how much tinkering you're amenable to, that is, the tradeoff between Freedom and time investment.cheersSeveral questions could have used a N/A (not applicable) answer, instead of forcing me to pick something nonsensical for my situation.I disagree with the concept of the freedom vs polish question. Free software can have it all.Yeah, I didn't think much of the assumption that 'packages' were a thing. Vanilla Emacs worked 30 years ago, works now, but I'll be really fsck pissed if the $CURRENT_YEAR Devops cancer craps up future Vanilla Emacs.There was a required question that did not have a none option, which would have been the only accurate answer.Optional email to be sent the results when they are available?Adding package popularity would be helpful in choosing between packages that cover similar ground.nicely made well doneOn mobile firefox the checkboxes and radio buttons were hard to clickthanks for doing this!more questions about learning process would be interestingUncertain how you could work that, it's been years I kept up with web development but the country selector is a bit too confusing/little hard to use when it never expands after being selected via vimium-ff. I cannot use the mouse so navigating this survey via keyboard only is essential to me (and other than the country selector was mostly easily doable.Please let me either enter „2-3 years“ in the text or give me a hint „only natural numbers“. Don’t just delete my text and pretend I did not answer ;-)Well done! ☺️I liked that I was able to navigate away and when I came back it remembered that I had started filling out the survey and what my previous answers were1) Some questions should have a none-of-the-above option. 2) The "How did you find out about this survey?" should probably allow multiple options. I saw it on lobste.rs, r/emacs, and HN before I had a chance to take it.Sorting of the Nationality was weird for "American". Got at least one 500 error. Fingers crossed.Some questions are mandatory, but they are about things I don't use.I would like to have an easy to configure email client. Configuring Mu4e is hard and it is not really stable. I would like to have some easy to use default keybinding set for beginners.The country dropdown always crashes on mobile.More clarity on optional qs before the gender page More no/none/not relevant. I don't do code on Emacs, there's no no-language option (for example)Maybe you could ask what mayor annoyances with Emacs are :)The question which asks for how many years I've used emacs only accepts integers, but I wanted to say 1.5 ;)For 'nationality', the selection 'American' is listed under 'U'"when you hear about a package what do you do next" should be optional or have a "nothing/don't know" choice among the responsesnoneI loved this survey frameworkI was unsure about terminology relating to "emacs" vs "emacs packages" vs elpa etc.emacs-nox, tty-console, TeX, and gpm are my friends!You buried 'American' in the middle of the list instead of listing it alphabetically. Otherwise, fantastic job.I'm not subscribed to mailing lists any more because at work we're tied to MS outlook. privately I use gmail these days but don't code much any more. _technically_ mailing lists are a superior mode of communication. but working from many different devices on the same email (phone, chromebook, work laptop) makes gnus the inferior experience. which brings me to my second emacs itch: how to have portable emacs data & config? so I can roam between machines and they synchronize their emacsen? reliably?Thanks for putting it together!The hardest part was picking only ten favorite packages that I use daily in Emacs.Very slick and snappy. I appreciate that you have decided to use minimal JavaScript. It reminds me of the older days.It's great that it exists, please do similar things. I'm very time/energy constrained.Very slick and stylish!Marginalia makes no sense in the question about selection packages, as it's not a selection package. The distinction between fully-custom configuration and lightly configured Emacs is unclear.Thanks a lot for having this survey!Not I don't haveIt would have been great if there was a section on other editors used, why other editors, missing competitive features from other editors etc. way back I used emacs 100% of the time but in recent years I had to move to IntelliJ products (java in emacs was painful) and pretty much all my coworkers seem to have moved to vs.code despite telemetry/spyware issues.Make it easy for new users to get into Emacs ecosystem, ship a default non-bloated starter kit so that eventually users like myself can transition to realize the power of Emacs.Survey needs “none of the above” options for required questions.It looks and works great.More emphasis on what I currently dislike about Emacs.Thanks for the effort to make this survey. I like the responsiveness of this website.Great job, this was *very much* needed!I can't tell for sure and I haven't poked particularly deeply, but it looks like this survey platform uses Pico.css, my favourite CSS framework 🤔 I really like it and I very much approve!To everyone standing behind GNU emacs and putting in work: Thank you for this amazing editor/operating system ;-).Thanks for putting this survey together!Pretty long, but hope it helps make the project strongerUser Experience testing against a variety of user demographics and Emacs/computer literacy would benefit the survey. Knowing how users interpret each question, by having them speak aloud (if they are verbal) their (otherwise) internal monologue and thoughts when they're reading and completing each question. Testing the survey against expectations will help ensure it's resulting data are interpreted correctly, and more prose can be written for the survey and the survey revised as needed.There was one question early on that seemed like it should have been multi-select rather than radio button (minor enough that I don't want to risk chasing back through the survey to find it and maybe losing my responses)Good user experience without any unwanted Javascript.The nationality list is partly broken (e.g. New Guineans).Thanks for not javascrippling it! There was a question about how I proceeded once I learned about a new package that required an answer, but none of the answers seemed fitting for someone who doesn't even get news about new packages and hasn't installed separate emacs packages in decades. I sensed a very strong focus on packages in the survey, that completely mismatches my experience and constant use of emacs. I'm not sure my answers are going to be useful. A question such as "do you ever install separate packages" that collapsed that entire section if answered in the negative might have made more sense.Allow clearing of the selection, so that optional questions need not be answered though we may have accidentally selected an option at first. "Frequently" and "Often" are basically synonyms, would be better to eliminate the "frequently" option. "How often do you contribute to Emacs or ELPA packages" could be read as "how often do you contribute to Emacs packages or ELPA packages" when in fact you probably meant "to Emacs itself - the Emacs source." I suspect at least some respondents will mistakenly assume that contributing to Emacs packages counts on this one.Long live emacsNo questions regarding what I think is important for or lacking in emacs. If there was one thing I could wish for, is that there was more focus on multithreading. As it is now, I can't really use emacs for my daily work.It is really too long and some questions might be redundant.Eliminate stupid word limits, it's completely arbitrary.You might want to seperate the features and UI in the question about free software. I think I can accept a feature limitation but UI starts being important as UI on GNU/Linux is getting smoother every year. I trully think Vanilla Emacs should get a lifting.Superb job. Let us know this survey resultsI feel like there is multiple questions that are very same, not entirely same but they are like almost exactly the same, i think those questions should be just one question instead.a section for people to suggest more questions. maybe the feedback section is enoughI liked the part where you assumed everyone cares about new packages :p For the most part my workflow's fine as is already, and I don't want to depend on a lot of stuff I don't really need.I used emacs heavily in University 20+ years ago then left for a while b/c I thought it had stagnated ... little did I know! I came back earlier this year and I'm glad I did!It would be nice to have an intro as to who is running this and why and to have a date/location where we can see some feedback on the resultsit was too long...My biggest issue with using Emacs is performance (stuttering) on mac os, there was no convenient open question for this, or I might just have missed it.None that I can think of. Fantastic job on the survey website, and I can't wait for the results <3I'd like to see stats about the prevalency of LGBT+ people amongst Emacs usersThis was fun! I'll gladly take it again next year.Thanks for developing Emacs. I use it more than any other application on my computer.Nope. Hope it helpsFew small issues such as the nationality select item had `New` as an option.Well done, it looks great!Thank you for hosting this; I regard emacs as the greatest program so far created.I was not expecting this to run so smoothly, or look this great. Incredible job putting this together.Great survey, thanks for organising!"American" is weirdly placed in the nationalities select list, making it hard to find.The questions and answers run together in w3m. But I'm grateful it works without JavaScript. Thanks for organizing.thanks for your hard work :)This could all be auto filled from in emacsmail client question did not offer a "multiple" optionWorks great on mobile.These was a great, accessible survey. Thanks.I hope this helps.Too much "must answer" questions.Wasn’t sure if the framework/starter kit questions are meaning something like Spacemacs, therefore I chose other for many questions…This is *much* nicer than survey monkey et al.Make it more clear which answers are required.This survey is too longI wish it would be easier for me to learn to handle emacs. There is so much information out there, and I never found something basic that gives a clear introduction.A couple of the single-choice selections should be multiple choice, especially for previous editor, I use multiple.Maybe add a bit more investigation about community interaction (e.g. "I mentor newcomers", "I try to answer questions when I'm confident I can offer useful help", "I ask for help fluidly", "I ask for help with trepidation", "I write manuals", "I moderate a Discord server", etc.) If the survey is going to include questions of gender identity then it needs to both state a purpose for asking and be a bit better aligned with the fluidity in that domain that people currently express. I know this isn't an easy domain to navigate well but developing that skill is part of the challenge currently faced by the Emacs community.I think that this survey unnecessarily excludes people who are trying to enter the Emacs ecosystem, but from some reason can't do it. Also there's a typo: Which operating system to you use Emacs on -- to instead of do. Which editor I was using -- a radio box? I'm currently have 3 different editors running on my OS (vscode, clion, vim). How am I supposed to pick one?It may need to differentiate more clearly between built-in and external packages.It would have been great to see some introduction on the intent of this survey and the reasons behind it.Questions are great; the platform would be better if you could do question branching. Also, while I totally love a cookie-free world, I wonder how well your IP address XOR method is going to work in practice.Thanx.I like that it's anonymous. Most of the questions are straightforward. Every question could benefit from an Other checkbox. There were no questions about biggest ongoing issues with Emacs in daily use. Thank you for Emacs.Love what you are doing; doing amazing.there were a couple required prompts that didn't really apply to me. It's extremely rare that I install packages - relatively speaking it feels like I just installed use-package yesterday, though I know it has been a few years. And the only reason I install packages is when I am learning a new programming language so I need a new mode, so the question about installing packages didn't make that much sense to me since it kind of assumed I install packages as a hobby and not when I need to do something for work e.g. edit terraform files.You should have a question about what new features users want in Emacs.Start off with questions on packages.Questions seem very programmer centric.Should include a Common Lisp option :)Continue the survey for the next years, please! It's awesome! Good job!Keep it going into the future.pretty long> I have a clear preference for free/libre software but am not willing to accept a lack of features or UI polish This question doesn't really capture the tradeoffs associated with free/libre software. Just to use Emacs as an example, it lacks features and UI polish compared to something like IntelliJ, but it's also true that Emacs has features and UI features that are only truly enabled by its free/libre nature. (ie: I can hit a couple keystrokes and see/modify core code, etc.) Where free/libre software can suffer is in issues of interoperability and in development scenarios where deep, ongoing investment is required. A need to work with a colleague on a complex Excel model might steer you to buy Excel (over gnumeric, etc.) for reasons that have nothing to do with UI polish or feature set.A high-level privacy policy and data storage policy for personal demographic information being requested would be nice. I decided to trust you guys but was debating it.Quick survey and good, non-vague questions. Enjoyable to go through!This was awesome thanks for doing this!I hope the insights lead to overall improvements. Long live Emacs!missing question about requesting new packages and improving existing onesThank you for allowing us Tor users. Normally we get blocked.Some mandatory questions should be optional.I would have liked more specific questions about use, e.g. how often do you have emacs open, what is your initial major mode, do you use init.el or another system, etc.Very smooth and pleasantMany questions hard to answer if you don't ever use packages.don't make as many things required - some have no bearing on me and don't have an other categoryMake the programming question optional. More questions on org mode vs. Obsidian. Lack of polished mobile app for org mode pushes me to Obsidian (beorg is too cumbersome in comparison to use for task management).When entering something in the input field and then unchecking and checking again, the input is lost. This should not be the case. Thanks for giving everybody a voice in this community.I can enter negative numbers for things that make no sense being negative. Also, the English grammar is, at times, questionable.tad too long. But anyways, thanks for doing it.The survey is great, except it doesn't have a option for me: I read in high school.You didn't ask if I compile my own Emacs or if I stick with whatever my Linux distro gives me. I used to build XEmacs back in the dark ages, then Emacs, but after version 24 or so I've found that my needs are served well by sticking with either the Debian Stable or Fedora emacses.I hope one who read that have great dayKeep up the great work. Free software rocks! GNU/Emacs is the GOAT.Switch "American" to "United States". It was weird to see it in the wrong place alphabetically.Mixing functionality and UI polish in one question sucks. Looks are less important to me than usability and features!Ask about other IDEs / Editors I may use, many of us use several. <3The question "What is your level of Elisp proficiency?" should probably be multiple choice. Several of the alternatives weren't mutually exclusive/subsets of each other.Keep the good work up!Thanks for your work to the community.More questions about demographic and acceptance would probably be a good thing to test the inclusivity of the communityThe question about keybindings could be open for multiple choices. I often go back and forth on vanilla and evilThe package questions should be optionalSome questions need a "I don't" option. The programming language section should add Common Lisp (there are several much more niche languages there).Prove this is useful or stop being so noisyIf I don't select any packages and I can't contact and maintainer so don't make me fill out that fieldThanks! Although, some non-answer responses should be allowed when I prefer not to respond to a questron rather than fit my response with the articifical constraints of the options present.no question about emacs weaknesses?emacs is slow on latex!!!!Thank you for the time and care to craft the survey. It's very clear and easy to fill in.Great initiative!You should ask questions that reveal the racialized position of the respondent. The software industry reinforces racial, caste, class, gender identity, able-ism and other forms of dominance and oppression. The FSF still has the potential for dismantling this, but continues to reify dominance across the globe.Some of the required questions had multiple choice options of which none were applicable to me.Keep up!Survey seems fine. Re emacs, I'd love multithreading so that I can use emacs effectively as my window manager without hangs and pauses.idnFewer required questions.You should ask what are the worse things about emacs.Emacs should have this survey built-in, like it has bug reporting.Just randomly found this survey on some blogpost. I wish this kind of surveys propagate more frequently on the web. This is a perfect alternative to telemetry. Keep it up!n/a, kudos to those who are maintaining emacsI would like to see the results published to the publicIt would be good, if upfront you asked if I use, or willingly use, emacs.It would be nice for later questions to be shown based on previous answers. I answered that I did not write any emacs packages. There were many later questions involving those packages. That way, the survey could be more in depth and take the same amount of time.Is it possible to separate the use and contribution sections or toggle the questions for contributions?The boxes for free text only has two lines and can not be resized.Long!Thanks for your work :)It would probably be helpful for the evaluation of the survey, if there were the possibility to add several options to a question. I had to separate two additional languages I use Emacs to program in with a comma. Otherwise: great job!Why don't you list all the questions in one page?None.I'm Yao MingI lost my "other" response when I clicked to the right of a text box (unchecking the box and clearing it of its values) :(I love talking about Emacs. This was fun.You could let the users add more than 10 packages via some list (check boxes) because i thing this is the best feature of Emacs. I refer to it's ability to manage a load of packages in real time... This for me is outstanding!! Well done guys!!I'm glad to have learned about Tramp :)Thanks for your great workYou should advertise it through other mediums—universities, colleges, schools, etc.Thanks 🙏Some questions (discovering new packages) were not really relevant to my use case, but were mandatory.Why are ANY questions required? When a required question has checkboxes, there is no way to select none of them (e.g. which documentation do you wish packages provided).Glad it works without Javascript. One problem - scrolling with the trackpad regularly caused selections to change. It would be good if changing options had to be explicit with a click or drag.Thanks for the effortI have been using Emacs less than a year. I entered a decimal value into the "How many years have you been using Emacs" field, but it had an error in red about not being an integer. I changed it to a 1.I think Emacs is nice but I do not use it. Sorry.You should have asked if what, if anything, keeps me from using emacs for shells or email.share the results publically and w/ FSFWas on a train and internet kept dropping out but I was able to resume where I left off, this hasn't worked on other server platforms I've used so that was goodI used to revere Emacs, then I realized I was just evangelised (if not brain-washed) into its church. It has been my first IDE, and I'm very thankful to what I've learned. But, emacs keybindings are insanely frustrating, not to mention an hazard for the user's hands. This is what eventually drove me away. I wish this aspect would be surveyed in a deeper manner in the coming surveyKeep at it, it’s great to collect data!Cool survey"Do you use any selection packages?" question is very poorly formulated. The question and its answers does not make any sense. Neither consult nor marginalia are completion frameworks.I am really noob on emacs. I thought it was easier to make notes and honestly it is, buy omg this is so much knowledge to understand the usage of Doom eMacs. I have little experience programming, i do stuff like simple linear regression and graphing on python, buy i feel this like some other level of programming. I'm willing to understand eMacs in order to organice my knowledge.Smooth experience!Nice work!I'm glad there's this positive meta-awareness we in the Emacs community have. It gives users the opportunity to talk about their favorite editor, and contributors the opportunity to gain an awareness of what's important regarding Emacs.Thank you for running this survey, and for implementing it in such a user-respecting way. You managed to make the survey visually attractive yet very responsive, and not requiring any JavaScript at all. Well done!* I don't know why it needs js. * The survey seems mostly targeted at either newcomers or the folks directly involved in emacs-devel.Thanks a lot for this survey! Believe me, this data will helo all of us for a very long time!Maybe get an indication of how people hope to see the direction of future emacs development, e.g. large stand-alone packages like helm vs. smaller, flexible frameworks (vertico, selectrum etc.) that build on built-in mechanisms.I use emacs as a code editor, and lack of integration withe tree-sitter (I know that it merged now and eglot) affected me in the last years, especially since neovim, and vs-code surge past the capabilities of emacs in the recent past. Also lack of a decent TSX/React plugin is affecting me in the front-end dev.Inform beforehand the number of pagesIf you have a limit of 10 on #favorite packages then say so - don't throw an error! Also, mention that "comma delimited" excludes spaces!Some questions were required for which I had no answer. Those shouldn't be required.Some questions should be multiple choice, but are single choiceIf you're interested in what packages people use, wouldn't it make sense to provide people with a script that they could run which would upload that list to somewhere where you could collect and tabulate them? America is 2 continents with many nations. Canadians, Mexicans, and Venezuelans are all "American". It's not a nationality.You can skip questions about gender, nationality etc.For the gender question I would add in a non binary and a prefer not to say option.Not really...maybe some freeform text boxes should be more prevalent. e.g. in the section about whether Iprefer libre software with X amount of polish, i would also have liked to clarify my position a bitThe question about editors used before/alongside Emacs would benefit from having checkboxes instead of exclusive one choice.Snappy and responsive. Free text/other answer boxes could be larger. If I go back to a previous page, it would be nice to have a way to jump to last page with answersI started using Emacs this year but I couldn’t enter 0.25 years at the beginning of the survey due to an integer type error.I feel like some question were very important, thanks :)Short, but nice. Made me think and realize that emacs is pretty important to me overall haha.With well over 100 packages installed, I think the top 10 limit was a little small ;-)Thank god you're not using google formsThere should be more "I do not yet have the skill level, but would if I could" options for contribution and package maintenance to separate new users from long time non-contributors. The question about free software seems to assume that UIs are generally better in proprietary software which is the opposite of my experience. I have to use MS Office and Windows at work, but I have installed LibreOffice because the better UI. When I turn off the toolbars and on the sidebar, I get 1/3rd more space for content I in LO Writer than MS Word and ctrl-s and other common keyboard shortcuts work like expected. The ribbon UI in MS Office demands more mouse clicks, hides functionality and keyboard shortcuts (unlike menus) and eats pixels in the direction all screens have the fewest. I think the question perpetuates a falsehood about UI design in proprietary software. I think Emacs' text and keyboard-centric and clutter-free UI is very efficient compared to most other text editors and IDEs.I appreciate you doing thisToo long a survey. Should be just one page(IMO).The free/libre software question would've been better stated as open-source software as I'm equally happy using something that's BSD/MIT/Apache-licensed as I am (L)GPL.One shouldn't ask for Nationality.♥️Just before the deadline (perhaps send a reminder?)! Excited to see the results.Bit longThank you for taking the effort to run this survey. It seems well thought out and an important initiative.I like the "pure HTML-forms + CSS approach with server-side rendering" approachThanks for putting this together :)for the "where did you hear about emacs/why did you start using it" question, I wanted to fill in a text answer. I used emacs because it had the best clojure tooling at the time (2015)The question "could you list some of your favorite packages" should indicate that there is a limit of 10 packages straight away. I was slightly annoyed that I have to revisit the question...Thanks for building your own platform for surveys, for doing these, and for planning to do all the number crunching right before EmacsConf! :)It would be nice to get a summary/comparison of the all the options listed. For example, if I use X completion or Y package manager then some introduction to the others. In general, if I mainly use Z then a introduction/alternative comparison can be helpful to make better choices.Needs more multiple entries, for example, I saw the survey on emacs-devel, r/emacs, and HN, but didn't respond until I had the time to do so. Allow open text entries for explanations after selecting the answer. These can be useful to identify questions where the ask was confusing or context absentThe questions on page 4 were ambiguousLGTMSecond to last page crashed several times for some reason but eventually worked on Android Firefox. It recovered nicely with a refresh thoughIt was pleasant to complete. Clean UI, intuitive UX, no Google Forms bullshit.donation link would be nice, love this initiativeIs "American" my nationality or would it be "United States"? Why was "American" not sorted alphabetically?Thanks for not requiring JS. Some questions were unanswerable for me in their current form, namely: "When you discover a new package that looks interesting, what do you do next?" I do none of the listed; I always inspect the package code before installing. (I checked all options to be able to continue.) "Do you use an Email client in Emacs?" Should be multiple choice (e.g., I use both Gnus and notmuch daily). Similar with "Do you use a project management package in Emacs?" or "Do you use an undo package in Emacs?".The Clicking area for radio-buttons is too large (whole width of the page), it's a bit confusing to accidentally click on whitespace and change an answer. (On Firefox at least)Great job on organizing this effort! Thank you! :-)Thanks for the great job ! =)High School as the minimum education is too high. That means people who have not/not yet graduated high school have to lieYou asked about pain points when learning, but not current pain points! CJK font rendering is too slow.- The nationality selection menu was a bit clunky and broken: - Ranking the Nationality titles according to alphabetical order of the country's name in English led to some strange ordering (e.g. American down near the bottom, according to the alphabetical rank of "United States of America" - Some multi-word nationalities were broken over many lines (Cape Verdean, Central African, Costa Rican, Equatorial Guinean, Puerto Rican, Sao Tomean, Sierra Leonean) - Possibly including some nationalities twice, in both the anglicized form and the name in the original language (e.g. Cymraes and Welsh) (Note: perhaps there is some difference in those who would designate themselves under one term vs another; I am not sure what the status is regarding the use of such political designations.) - Formatting of the page is a little funny when displayed in eww.Make the results public and pretty, like stackoverflow's annual surveys.Thank you for your terrific work.No, not reallyThank you so much! You make the world a better place.This was a great survey!have you heard of NixOS?thanks for organizing this surveyThis is just a very low-priority feature request, but the ability to submit using email plaintext would be great.Maybe make it adaptive. For instance automatically exclude all related questions if a person answers no for some main one. For example contribution. I never did that but once I marked that in one of the first pages, I had to do that again and again in others. For me it is ok but I am sure may would skip the survey if they need to answer unnecessary/double questions.There should be a lot more "No" options.free form question on problems, issues would be helpful, I assume (but also difficult to evaluate)It was great.a question about missing or desired features or packages would be interesting, also to know what things are painful about emacs to most people to know what could be improved.I have been using Emacs less in the last several years because I've been using mostly Julia, and Emacs support for Julia, especially on Windows, has been poor.The worst part about Emacs is the fact that it is associated with the FSF, who decided to put Richard Stallman back on their board of directors. He is a reprehensible human being and I will not support them as long as he is associated with the FSF in any way.newpI didn't understand the question "Have you got any feedback on the Emacs/GNU ELPA contribution process". What does "feedback" mean here?Looks great! Very clean UI.It's fine. Nothing really needs to change.Trivial issue: it wasn’t clear (on mobile) that I had to enter something numeric into the ‘how long have you used emacs’ field.Emacs makes my life easier and without it and the community that develops it I would be a very different person. I would have to use vi.Would be nice to know results of the survey and get informed on how to proceed (learn/improve) in the areas that I don't know about.Some questions were missing the free form answer, e.g. the ones about contributing to packages: My primary contribution so far is that I package Emacs packages for Debian, i.e. provide them in Debian as .deb via APT. Also for the completion packages question I would haven wanted an "not sure" or "don't know" answer as most of them seem to have been pulled in via dependencies. So I just checked all which I found in the list of installed (Debian) packages.For the input methods, it's unfortunate that it's an explicit question, e.g. "built-in vs VIM vs CUA"; I switch between all three, but use VIM primarily. Asking for the "primary" input method would have been less ambiguous, or allowing multiple answers. Other than that: great survey, especially the technical part, no hiccups. Thanks for providing this!I am very happy you do this survey; thanks! Some ideas for improvement: "Frequently" and "Often" are not good options. There are probably standards out there for survey options you can consult. Specific frequencies could be used for things like "how often do you use...": daily, weekly, monthly, yearly—or even "__ times a ___". Emacs Wiki doesn't seem to be mentioned on the survey; it's a significant way I (still, after 31 years) learn about emacs. Have you thought about making recommendations to survey participants based on their answers? Something like, "Hey, you might be interested in the mailing list" or "Look at this if you want to level up your packaging skills". The questions about packages and contributing made me feel a little guilty about not sharing my code (and keybindings); maybe that will motivate me to do so!No. Thanks for organizing this.to many redundant questions on contributions irrelevant for non-contributorsA bit longer than expected ;pThanks for creating it.- some options missing: what do you do when you find packages → nothing - great, works without JS! - you should provide context, e.g. is this official, is this accepted by the FSF - you should mention the methodology you use, to show whether this is an informal hobby project vs. a statistically accurate survey. I.e. are you taking into the account everyone who: could not answer the survey but wanted to; boycotted the survey; tried to submit fake data; answered multiple times; didn't even know about the survey; didn't speak good enough English; etc.Keep going, it is a great job for Emacs communityYour questionnaire needs a serious kind of attention...so much vested stuff in it.It is a very well designed, thorough enough and overall enjoyable survey.I think this has been the most seamless online survey I've ever had the pleasure of taking. There was something very smooth about how the questions and choices were laid out. Great job. Two minor criticism I can give is, firstly, that the 'none' options weren't in a consistent place across questions—sometimes they'd be at the top, other times at the bottom. Second, in the financial contribution questions, it feels right for me to place the 'I would like to, but cannot' option first.Thank for you doing this! This is a great contribution to the emacs community :)A question on what user would like to improve in emacs.Thanks for your workWhere were the questions about improvements we'd like to see? I might have just missed them.next time make an emacs package instead of a webpagePlease reduce the number of required questions. I use emacs because it works. It's not a lifestyle choice.Was quite lengthy but I guess there is nothing you can do about that if you want this level of depth in the gathered insights.Thanks so much for your work on this, and all your other contributions!More questions should have a "did not" optionGreat, thanks!Some of required questions are weird if you don't contribute to packagesMaybe next time first create a draft and ask the community how it can be improved. (If you did and I missed then sorry.)When I first tried to take the survey, the platform seemed to have crashed in the middle of it (I got various 502 pages). After the server recovered I had to restart the survey from scratch.Some of the survey buttons are too large, making the blank space to the right of the button a hitbox I accidentally clicked on multiple times. The media query for the previous/next page buttons doesn't remove the right margin on the previous page button.Do I get a cookie now?Curious there aren’t questions about whether respondents engage in local advocacy or encouragement for adoption of emacs–I definitely do. Also, no questions on what killer feature is missing? The lack of real multi-tasking or task manager in emacs is a bummer. pairing/screen sharing/presenting from emacs is a little stressful knowing that having to kill the whole emacs process isn’t merely a remote possibility. Oof. Otherwise, emacs is dreamy. Love it.can't believe you had to write your own framework.Limiting to 10 favorite packages is hard. Some UX improvements there would be nice: indication of how many packages are currently in the list, and/or "pills" UI to make it easier to remove packages from the list.I would use emacs a lot more if it supported better intellisense/autocomplete features. This is pretty much the only thing that keeps me on intellijMake detailed results publicreally solid survey, site works well and looks decent, easy to change previous answers "male/female/specify" is a bit weird for gender options *however* i think it's somewhat smart - it saves you the work while serving as a general catchall optionMaybe some more options relevant to new users of emacs.It's pretty good :)Nope. Congrats on the keep the pages minimal. Good work!clicking near radio-button fileds if you have already filled in the "Other" option clears the "Other" option :( - otherwise great!Keep doin' this. More info always helps.Nice surveyWhen requiring an answer to multiple choice question you should make sure at least one of the choices actually applies.Maybe try rankable choices instead of "check all that apply" for some questions.Love the colors and spacemacs.Some questions could've used an "aggregator" option (e.g. Planet Emacsen). Technically it's RSS of a blog post, but I wasn't directly subscribed to that feed nor was I checking the blog itself, so I feel like "blog post" does not exactly qualify.Nationality menu annoying on mobileGald this survey is being done! Let's make sure the most powerful free editor continues to thrive and reach new heights!Perhaps the question "Have you signed (or attempted to sign) the FSF copyright papers?" would be more valuable and less confusing if split into two, e.g. "Have you attempted to sign" and "If yes, did you succeed in doing so".No third party modern web crap is nice, an in-Emacs version, a simple package who send data to a server would be nice AND allow potentially more honest and constant feedback...Maybe it would be a bad idea because other people don't want to spend a long time answering questions, but I wish there were more. I would be happy to answer more questions and I want to see the community's answers to more questions. Emacs is my favorite program, so I'm perhaps... unusually interested.I love emacs, thanks for doing this survey. Hope emacs gets better and more widely used.Looks very goodSome of those questions seem to be tendentious.Maybe an open ended question? Would be good to reignite the old "let's change the defaults" flame war :)Good job. Allow selecting Vundo with other Undo-Fu?Best to take on laptopSurvey is great, this is what will help emacs to stay relevant in a world where vscode / neovim existsThis is really long...It's mostly great with a small glitch: if you edit a text in the "Other" box and click with the mouse on an y-position equal or above to that box, the text gets lost and must be re-entered (but that does not happen e.g. for this box here).Should collect the list of most "hated" defects, I think. What users really would like to have fixed.Please include the Fediverse as a social option in the future.Finally a survey, where it is not a requirement, to load shit loads of third party tracking bullshit. Thank you for that! The survey pages have a very clean and simple look, well readable, not overblown styling or unnecessary animations or all kinds of other stuff. Simply getting to the point. I wish more surveys were like this.Well done! A couple of items could've perhaps used multiple choice instead of modal, but rarelyThe key binding question was either-or, yet it's possible to use both (which I do). I was able to use the other box, but now that response will not count or will require you to correctly parse itLearning there are character limits on text boxes after hitting submit is not the best UX and could be improved by having a running character count with the total possible like `20/100` which gets updated while typing.What are our problems in using Emacs, is missingI do surveys through the remaining teeth I can still grit.Message boxes are a bit small. (I am writing from my telephone) I think the a second survey can be done which is more about collecting more and opinions on emacs.What's the survey software? It's greatKeep being great!interested to see the resultsReally good job. Looks nice and feels nice. All the writing is correct, and everything is clearly communicated. I'm impressed.some of the questions about packages / contributing to packages lack a "don't know / never thought about it" optionOn the survey design. I would prefer one page of questionsToo many required questions. But thanks for doing this and improving emacs!No questions about what we don't like?"must be answered" is not what I want to read again, particularly, if there where no sensible alternatives to select.Keep at it! This is awesome!Great job, thank you for doing this!Some mandatory questions? Seriously? And some multiple-choice questions with no "other" option?Nice job TecoMandatory answers lack any statistical validity, unless you include "don't know", N/A, or similar to denote the respondent cannot answer.Order of options is sometimes inconsistent. For example "no" at the top vs bottom in different questions. Consistency would make a little easier to navigate the options.missing feature: add "other" or comment as list of itemsThis survey highlighted how much I use emacs yet have given so little back to the communityMore questions on wiring prose, more questions on web development-interacting with servers.thank you for putting this together!!!! really appreciated!! Would like to to serve some $$$ to this surveys organizers... please post where i can do thattheme report is mandatoryIt just reminds me how much of Emacs I don't know or understand. :)There are contributions to the Emacs community which aren't packages, for example starter kits. This survey does not capture the effort of maintaining those and I contribute to/maintain one. Looking forward to the results from this one though! It's been a while since I took the Emacs Survey!In the contributing to emacs packages section I wasn't clear if that meant just code or also documentation and bug reports (like in the 3rd party package section).There were a couple questions where I would have preferred checkboxes (to mark multiple options) over the provided radio buttons.Thanks for creating this survey!Be sure to enjoy the outside away from a screen today.Would be interesting for a question asking how many lines of code for the config of each responder. That or some other metric for how much effort one has spent curating their config. Thanks for doing it. Interested in seeing the results!Hope this will help improving Emacs. Thanks for setting this up!nopeKeep the flame burning. I've had to campaign with others withing the company to allow Emacs as a tool and my productivity would be severely impacted if it were to die.Please list ways to easily contribute to eMacs maintainersToo kongI wanted to talk about missing things in emacs like proper multithreading, but saw no entries for thatRemove mandatory questions.Spelling mistake: "suspiciously advanced for you're age" - should be "your"I really appreciate the gender question. A free-form field is great.Often > Frequently. Very confusing that you used a different order.I use vimI like that it is more comprehensive than last year. Thanks for putting this together :)Could be good to add a section for feature requests to help guide development.Nice that it works without JavaScript and over TorI would have appreciated more questions about emacs versus other editors. I have a lot to say about both emacs and vim in terms of pros/cons and am interested in others' thoughts.Interesting questions!Some of the questions feel a bit loaded. In particular: Just because I'm willing to _accept_ something doesn't mean I _approve_ of it. Also, you could learn a lot about what the community wants by letting them tell you which features they'd most like to see in Emacs in the future.Emacs is my primary editor and I hope it will continue on for future generations.Seems nicely laid out. There was one middle section (involving packages) which was nearly a duplicate of a previous page.Reasonable length, good questions. If it generates useful information, it seems well done.Well-crafted, but directly pasting error logs on invalid input may not be the best approach, although it certainly works as a reasonable default in the absence of explicit catchers (eg putting 1.5 for “years using eMacs” gave an error, and without familiarity with type errors I wouldn’t know the issue was non-integer-ism). Also, it may be useful to give optional ability to provide reasoning for some of the multiple choice options, though the questions were well-selected enough that most relevant information was otherwise captured.- what you will use the survey results for (what are the objectives of the survey) - who is doing the survey (official, non-official?) - at least max of 40 packages (does it include built-ins?)long live emacs!niceMy one problem with emacs is Csharp support is really poor which prevents me from using itI’d be curious how many emacs users are liaising with other editors / ide’s. For instance, I use helix periodically and I’m sure some are using vscode some.I like helm and ivy, but they still have a tendency to be too slow for me. I keep holding out for performance improvements, but at this point I'm not sure if I'm waiting on maintainers of Emacs or those packages.Multi-checkbox items should probably not be mandatory, assuming that checking no boxes is a valid response.Thanks for your great work!Occupation should allow for multiple selection Stackoverflow missing in the "asking questions about packages field"The question "what version of emacs do you use" for some reason un-checked the box when the "how many years have you used emacs" answer was deemed invalid because I put 2 months, since that is how long I've been using emacs, but it appears that question only wants an integer.It's pretty nice with large text and everything.No, it's fine.Some of the radio buttons could have been checkboxes - e.g. saw the survey on HN, email etc.Don't be snarky when someone makes a mistake (writing the wrong version). It's kinda annoying.Some questions (especially re: contributing to Emacs packages) seem like duplicatesThere are quite a lot of repeat questions and sort of leading questions.thanks for pushing forwardthank you for the organisation of the surveyEmacs should publicize more that it is first Free Software or the first software under GPLgreatYou guys did a great job!Might be good to allow skipping questions (though I didn't try it)you can type characters in the numeric fields, as well as negative numbers, etcKudos. Something like this is thankless work, so I say "Thank you".Keep up the good work and have a great day!Thank you for doing this! :)<3 teco Thank you for the great work on this!no :)The incredible amounts of bikeshedding over the survey platform is counterproductive to the goals of improving Emacs. Putting "Free Software" ideals before all else is quite frustrating.Yes: I would love to try more packages but each time I try to get one installed something breaks in the installation process (repo unavailable, software error, missing component, version incompatibility, etc) and I move on because I don't have the time to research the problem (assuming that it can be fixed). I would guess others have this problem as well but none of the survey's questions seemed to mention it.Maybe you should ask feature we'd like to see in Emacs.Surely this cannot be completed in 5 minutes.Some of the questions were either duplicates or the distinction wasn't clear. The ones about contribution.There are a lot of required questions that have not answer that applies to me. I think this is bad. You might get wrong results, because people might just tick a random answer or quit the survey at that point (I was tempted to do so). For exmaple, I am using org-mode and no other packages and not looking for new packages at all. So for example when answering the question about what I do, when I discover a new package, I had to tick a random answer.Great work, this was very smooth and polished!Sometimes multiple selection might make sense where only one option is possibleIs it possible to illustrate the Emacs roadmap so that everyone who is able to contribute will have a clear scope?Thanks for making it free software this time.Ask about perceived advantages of other editors. You can't connect a local frame to an emacs daemon on another machine, ergo, TRAMP does not really compete with VSCode remote development due to breakage that occurs over tramp with some extensions, and this is a big reason I'm thinking about switching to VSCode. This wasn't reflected in my survey responses.I am confused about the question: "How strongly do the ideals of free/libre software affect your computer use?" In my area of work, I dont see non-free options that would lack features. Most of the time, they have more features than paid software.Glug brain like survey!Some of the survey options were confusing (e.g. American for nationality was unexpected). Some of the questions gave poor options and even seemed intended to box you into a specific result... giving like 6 options regarding Libre software with 5 variants of "I have a clear Preference for Libre Software" and only one alternative... that's just a poorly designed question. In addition, some questions (which forced a required response) really should have provided a "None of the above apply" type option...Java goes before JavaScript in alphabetical order. Emacs is huge which means sometimes I end up using nano instead for a smaller footprint. This survey did not ask about rivals or comparisons much.Regd the question on choosing free/libre over non-free, I think it should be split into 2. I am willing to accept an almost complete lack of UI/polish, but features supporting workflows are still very important.you should ask also about alternatives eg remacs usageThank you.Surprised at some things: * 200 word limit? Really??? * willingness to pay for polished emacs? I buy things like Fork, Dash, Little Snitch, Carbon Copy Cloner... which make life better on osx. I totally get that "free software" means free as in freedom but consider Carbon Copy Cloner which is a nice gui for rsync. Much rather pay for it then make my own equivalent and want those developers to continue to improve it and would be happy to subscribe to an "emacs app-store" or something like it on osx to reward people who improve emacs there. * use of emacs on old hardware (like this macbook from 2008) * use of other editors in addition to emacs. e.g. I use VSCodium alongside emacs for rust-analyzer and other plugins not available in emacs. * concerns about emacs slowly getting left behind by things like codespaces * general wish for a way to make emacs play nicer with modern browser dev tooling and things like wasm which could make running "native" emacs in a browser a real possibilitySome questions required responses but none of the responses were appropriate for me so I just picked whatever to allow me to proceed good luckThanks :)Really like the detail of the questions and the look'n'feel of the survey.Make it clear how many characters we have to work with if there's a limit. Should always display ie '42/400' at the top of a text input.Thanks for doing the surveys!I thought there was only one default Emacs theme (which is a light theme), but the survey indicates there is also a default dark theme. Maybe that refers to the default colors when running in a terminal?keep it rocking!At least it's not Google Forms.if there is a list of problems to solve for emacs, I don’t know about it; if there isn’t, it would be a nice way for me (and hopefully for others) to check how could they help with codeThank you really much for your time. Maybe could you ask people ´s readiness to old features removal / deprecation and reduced core Emacs feature set ? Thanks again, really, to core devs and to packages maintainers, as well.Options are very wide compared to the text, I kept changing things when I clicked toward the right side to remove focus and then scroll down. Otherwise it's alright.The question about what I do when I find an interesting new package needs a "makes note" option. I don't install new packages just because they look interesting. The package needs to solve a problem I have. The other responses to that question did not make sense either.Clicking on the blank space on the right-end unintentionally trigger item selection.Couldn't un-select a radio button to not answer an option question (my level of education is not listed because I'm not American and you don't have an equivalent over there, so I was trying to unselect it.)Some questions should provide the "Other" option.It's wonderful you do this! Please continue doing so.None of these are a big deal. You should probably ask "what's your country of origin" as opposed to "nationality", leaves out edge cases like in the case of American which annoys people outside of the United States (they're also technically American). Leaving out common lisp but including clojure and scheme (there are definitely more CL users than scheme users) is kinda weird. Do collect more demographic data including things like ethnicity, salary, etc etc. Also add identities such as nonbinary etc to the survey. It's useless in technical terms of emacs development but it would be nice to see data that may alter assumptions about the broader emacs community.Some questions seem too similar, perhaps merging some of the contribution questions to check boxesSome of the required question made no sense for my limited use of EMACS and therefore got nonsensical answers.Some questions should not have been required or had null answers. Eg which programming language, how I contact package maintainersGreat survey. Unfortunately, although I've been using emacs for about 30 years off and on, I'm far rom an expert. I generally work alone and am not the greatest at finding out things so I'm probably as good now as I was 5 years into it. Still, an amazing editor. I just don't that much of the features. PUT IT THIS WAY: I'm sure there are some things I'd like to know regarding emacs but I don't know them because I've never gone out of my way to even know what they are.The text input boxes for "Other" radio-button choices are a bit small.keep up the good workAmerican is not an inclusive nationality. Everyone between Alaska and Chile could be American.Nice job on the survey!! CleanI initially tried to fill it out in Emacs (using eww) but had trouble filling out the forms, possibly due to an eww bug.hi tecoMore! And more promotion/analysisIf it’s required to check off an option add “not applicable” or similarPlease make the previous IDE question able to accept multiple answers. Some users may be IDE-hoppers.Pls make vim gudWould have said "Great" to the survey platform question, except that I had to retype "Other" annotations multiple times after clicking in the wrong spot :)I liked the absence of third-part js.Great work!Great insightful questions written in a clear and reassuring way, especially the bit about "to the best of your memory".Some question would work well with "No" answer relevant to particular question.Thank you for continuing to develop Emacs!Provide buttons to go back to previously filled pages so it is not necessary to click several times to "Previous page" to check the questions to think about a general feedback.It's excellent, good work Tec.Some more questions should be optional (e.g. "How do you find out about new packages?": some people don't follow new packages and simply search for one when needed)Please add: 1. What do you want the emacs to focus on? 2. Are you satisfied with your starter-kit / self-created init files?Survey software is very smooth, great job! I just wish emacs performance was as fast* and smooth ;) * already using gccemacs with emacs29, but something blocking my entire single-threaded UI is a really poor experience.Multiple choices for the professional field question would be nice. Nice to see a form that works without JS for a change!What a community. Glad to contribute.modernise the hell out of emacs. Dired sucks because it keeps opening buffers and switching between files is a pain in the ars in a project with a lot of file. Scrolling off the screen would move the cursor which is extremely annoyingFantastic job with the survey, thank youany questions, hit me up at finn.frotscher@gmail.comi suspect the kind of feedback emacsland needs is longform prose discussion, but i guess you get something out of this.One question that might be worth asking in future editions of the survey: where would you like to see Emacs development go, or what new feature are you most excited about? (I'd say treesitter and the recent merge of eglot for the latter.)There were some questions that were in conflict with others. Like how do you contribute, and have you ever contributed.I'm glad this survey didn't screw up my free text entries not even once.The 'lack of features or UI polish' question is vague. I went with moderate because it's not clear to me what each option means. Maybe give some examples?Every single text entry triggered my password manager. Something is off with the text fields.Asking users to enter a comma-separated list of packages is not great.Great survey but you might want to fold a lot of the contribution questions depending on earlier yes and nos.People can have multiple nationalities. I'm French AND Canadian.Hi TecoLoveliest survey I've ever taken. I'm not exaggerating; the questions are thoughtful and the UI is fluid.All on one page is betterI think more questions about why you use emacs over other programs would be good. especially in the disagree -> agree scale. such as ranking different aspects of emacs importance: open source, extensibility, the eco-system (not having to leave emacs)Thank you for taking the time to create it. Looking forward to seeing the results.Farily extensive survey. I enjoyed giving my feedbackMany of the questions assume Emacs proficiency that I do not have.Make the next survey use Emacs' customize as back-end...   ;-DSome question are dupRequesting a 2022 version of tecosaur's emacs user survey analysisLove everything about Emacs, I really hope that soon I can start contributing. Please guide us. I am extremely eager to learn and willing to give my time to contribute. I just lack the guidance and training to do so. In blunt words "Please teach me everything I need to start contributing to Emacs, and packages, the whole thing, I am super excited just lack the guidance. I want to become a real hacker like you guys!" Here is my email if you would like to get a hold of me. Email: abeitani1991@gmail.comI am still learning emacs and stuff I have no tryed so far I migth get interested in futurethe "do you contribute/maintain Emacs packages" section was unclear about whether we're talking about core emacs components or any emacs lisp software (such as that available via MELPA)Keep up the good work and thanks for all your efforts.Some optional questions could not be left without an answer, forcing me to type 'other' answers like "None"This important survey can provide valuable insights to all who are contributing to Emacs development and promotion. However, it seems to me that the survey is mainly targeted at Emacs users who are *programmers*. But what about all of the *writers* that are using - or could potentially be using - Emacs? Not just professional writers, but anyone whose job, educational program, or hobby involves writing. Wouldn't you like to know more about how they use Emacs? What do they like or dislike? How could we get them to try out and start using Emacs? That's a very large group of (potential) users! 2). For some of the questions, you're allowed to select just one option, while multiple options might apply. This may cause people to check "other" and to write explanatory comments. To me it seems that this makes it harder to extract information (in a useful format) from the survey.Emacs get freezes a lot whenever a task is triggered (ex:- syncing the org roam database or lsp-mode looking for completions)Thanks for doing this again <3Some non-fiction writers using emacs as main text editor, which made me try Emacs. You can include options for non-programmers.It would be good if there was an open question for feedback that doesn't fall into any of the other categories. I'll put my answer here. I continue to be disappointed that the emacs community endorses Stallman's positions on child sexual abuse, as well as his pattern of abusive behavior toward women. He has repeatedly leered and made creepy comments to women in front of hundreds of people. Everyone in the community knows this. Yet, no one will take any action to remove him. It's been an open secret in the community that we shouldn't allow young women alone with him for decades now. And I've personally heard the heartbreaking stories from women when they didn't know this rule. Until emacs creates a safe space without abusive people like Stallman, I can't in good conscience be part of this community.Some questions make some implications that might be wrong, such as migrating from a previous editor to Emacs, which isn't the case for me, since Emacs can be used for other purposes than programming.Multilingual support might be appreciatedOn mobile previous page and submit buttons are different sizesTons of work I am sure, nice job.Nice clean interface, very pleasant to useForcing me to limit the number of my favorite packages to 10 wasted MY TIME.The survey lists a number of packages/tools which I do not know where to look for details (besides search engines). It would be great to have a website with introductory information and links at the end.Great survey and thanks! But also... Emacs really needs opt-in telemetry (with 100% transparency). That would provide higher quality and higher quantity data than biennial manual surveys.Add a poll for emacs most significant issuesI love the FSF. I hate the FSF imposing itself on Emacs development. Separate.InterestingOn contribution page, should ask for contribution out of the scope of money or development. I do organize emacs meetings every months and that is a contribution too ! Thanksyou don't allow for a "*slight* preference for free/libre software" in your previous question. Where can I see the results?I use the package 'try' to try new interesting packages before installing. This kind of answer is missing from the possible answers, in the question about it. Because there was no correct answer did I selected all.the features / UI polish question is a little vague. I often prefer free / libre software because the feature set is more straightforward or obvious than non-free alternatives, if not "clickably or visually discoverable"Maybe make the progress bar fixed to the topI'd like to find a section with user expectations, like "what would you improve" or something like that. For example what I really miss to completely remove vscode from my workflow is the lack of a usable file tree feature. The current implementations are completely unusable.emacsit is a little long and some parts seem repetitiveteco rocksGood luckLess mandatory questionsthx k!Thanks for great surveyDid it seems to me or was the optional section full of mandatory questions?Thank you!!!Several questions should have been multiple selection instead of single onlyNo question on Emacs 'advertising': I teach and demo emacs to my students; I have the Emacs logo on my laptop.On mobile I’d put the next page button first, rather than the previous page buttonI am sure devs don't need more ideas from the public about what's missing in Emacs as a platform, but that would be an interesting survey item. I am referring to big-picture items, such as threading, ability to draw more freely on canvas, extensibility beyond elisp (e.g. guile-emacs), etc.Please widen userbase, that's the way that we all benefit. See Blender skyrocketing past proprietary alternatives.I think the attitude to free/libre software questions is confusing. I'm old enough to remember before "open source" and to have bought things from the FSF on magnetic tape. The "free/libre" term is so associated with the FSF, it feels a little exclusive (I do understand why you don't want to say "open source", though). Anyway, I don't particularly object to paying for software, and if people are providing the software free, then I am entitled to get exactly what I am paying for. I'm not sure I can articulate that from that question. But this is still a better constructed survey than most, so congratulations on that.I would break down the question related to free/libre software preference in (at least) two questions. "UI polish" really doesn't affect my choice of software in any way (frankly, I'm not even sure what that means anymore...). Features are another story. I really don't think these two should be lumped together.Nice survey!The first time I filled out this survey, every answer was "missing".I didn't have the option to select that I don't ask questions to the authors of the package in case of problems, as I don't want to bother the authors too much, so I Google and then try to read the source or find another package.If you select a radio button question, you can't deselect it, even if it's optional (or maybe I couldn't figure it out)nice workHope to see the resultsso pretty.some of the package questions were mandatory; I generally go in bursts for installing emacs packages, but it has been years and typically use it vanilla now (maybe said mandatory questions could be optional)Too many obligatory questions about packages.Theme question should have a "not sure" field since I'm doing this on my phone.Great survey.Emacs Rocks!Fewer questions should be required.The text boxes behave strangely (no autocorrect, etc.) on Firefox Android.Some questions are required but don’t have responses that are accurateThe elements are too big so they sometimes don't fit in my screen.Too long!Thanks for doing this!- I'm very very happy that the survey engine is FOSS. - I'm very gratefull it does **not** require any external resources to work, and that it does not hit any tracker, it's very clean. - I'm very happy that the FAQ points to the source code of the thing. - I'm also happy to see that the survey is hosted on an open-source forge.could maybe ask more questions around community-building, e.g. meetups or information sites like Emacs news or irreal.orgIt would be nice to have options in some answers that can portray the sentiment of "no, I haven't used feature X because I'm still learning, but I would like to use it in the future"... perhaps "not yet"?More emphasis on what we'd like to see in emacs in the future would have been nice. this seems backwards-lookingYes, I'd like to say "thank you"! :P Looking forward to the results!The survey is well-designed. The UI is excellent. I read on r/emacs that it's implemented entirely in HTML/CSS. Very impressive.I have a clear preference for free/libre software and am willing to accept any lack of ui polish but very little lank of featuresSeems odd to require answering questions that assume I'm a software developerWish I didn't have to click through so many pages. Felt like some questions were redundant.The wording on the org-mode question is unclear, i don't use org-mode but there are use cases that it could fill that i use other software for. The options are limited, Github is not the only git forge around, the fediverse is about as important as IRC and yet is not mentioned anywhere, etc. It's also not clear what "starting to use Emacs" should mean. I *first* started using it like 5-6 years ago but stopped using it for a while. I only started giving it a more serious try about 1-2 years ago when I got more into Guix.Any documentation page, or most of them, related to emacs is not ideal to be consulted on a mobile phone. Websites are not responsible, and the HTML looks pretty outdated. It would be great to “modernize” them a bit, making them more accessible and nice to the eye.I guess I would love the option to elaborate on any of the options but I don't think it will be useful when gathering the dataGlad to be part of this community! Thanks to the organisers :)Lonkero The mentioned packages at The end of this sutvey so one van ExploreThe survey is great!It demanded that I answer three questions without offering any appropriate option for me: + "When you discover a new package that looks interesting, what do you do next?" – I install it and, if I ever have the time, and the package still works on my system and hasn't been rendered obsolete yet, I try it out. + "If you wish to contact the package maintainer(s), how do you do so?" – I've never done that yet. + "Where do you ask for help using packages?" – Ditto.I liked the look of the survey. Questions were good. There could have been a section about features/aspects that wish Emacs would improve.Thanks for taking the time.Put the Never - Often things on a horizontal bar so they don't take up as much screen spaceThanks for crunching all these survey replies.every question should be optional.education should be more internationalized, in germany it's common to do an apprenticeship for example. So it's above high school level but below bachelors.Some of the optional questions were requiredThank you for your work!Need more questions on Emacs criticismsRelease The Raw Data!Could add a 'wishlist' questionI'd not know about the FSF copyright papers, but there was no answer reflecting thsI don’t know what version of Emacs running but that wasn’t an optionThe survey is good, but it should allow the respondents to give general feedback about Emacs (not only in the context of starting to use it), so I will use this opportunity to do it here. There are many areas in which I think Emacs should be greatly improved: - (much) more beginner-friendly OOTB experience - easier discoverability of documentation, keybindings, new packages - Tramp is way too slow. It desperately needs to be improved. It is a brilliant package, but I often have to give up using it because it hangs. - Dired is also brilliant, but way too hard too learn. - Eshell is fantastic, but it is too slow, and sometimes awkward. For instance, it should allow the user to set it to that remote paths can be expanded automatically: for example, if the working directory is on a remote host, `cp /foo/bar /baz/` should expand automatically to `cp /ssh:host:/foo/bar /ssh:host:/baz` and `sudo cp /foo ...` should expand to `cp /ssh:host|sudo:host:/baz ...`. It is very cumbersome to have to type long Tramp paths, especially when there are multihops involved.You could have added questions like: - what do you like to change about emacs - what do you think maintainers should work on - do you use LSP? and what do you think about the performance? - what do you hate about emacs? - how often do you (re)start emacs? (just fun for the stats)I wish there was more specific questions they seemed very general. I wish there was more options for certain things like if i have or have not used a model editing packageNope! Ya'll are great!👍🏼Add Common Lisp to the language list.I don't understand what you learned from that kind of questionsThank you for time contribution building this survey.The free software question ought to have an "other" or else it may as well be a slider with how 2-dimensional it is.I intensely dislike multiple choice. sorry."Papua New Guinean" nationality got split into three different items, "Papua", "New", "Guinean".it would be great of emacs didnt crush when in deamon mode and my kill history went to large its stupid when i copy some random text in a brouzer lets say and i go to emacs to do something and i kill some random word and it freezes. It would me nice if the kill history is something like a separate thread and if it freezes to stop only it and not everythingThanks for doing it.More in depth questions about libre/fsf software preferences please. The questions are too biased toward the author's point of view it appears. The point of view -- "libre" software can impede software adoption and stifle innovation due to decidedly unfree license constraints -- definitely was not an option. Not contributing because projects were GNU licensed (vs. more equitable and inclusive licensing such as MIT and Eclipse) was not a survey option. C# was prominently available as a language choice in the survey, while Swift and Objective-C were not. These languages have a higher adoption and usage than half of the languages included on the list. Why the Microsoft love and the Apple hate? (Doesn't Microsoft still deserve FSF hate? :)Good jobs, guys, and hope you'll make emacs great again. (haha)More options need text boxes for free text entry. Sometimes my actual choice wasn't listed.It's great. Much better experience than a previous Emacs survey that relied on a nonfree platform.If you could do this without javascript, I could have filled it in from Emacs ;)Survey itself not but the only reason vim is still my workhorse is it's lack of performance compared to vim.The learning process is a huge barrier and vscode is gobbling up mindshare. Better GUI interactions, package management, and LSP support are really important. I switched to Doom a couple years ago to simplify my self-managed configuration, but this just isn't discoverable to new users and it's intimidating. Emacs upstream should take a more opinionated stance and work toward a better experience for new users, perhaps with improved discoverability like counsel-M-x and package suggestions.You made some answers compulsory, but I couldn't give a good answer - I wanted to put 'NA' or 'I don't know' but it had no such option.i use arch btwno.Some required question with closed answer where hard to placate on my situation. I globaly feel that too many question are required (even I would have answer to a vast majority of them).Good job as a whole! I doubt some of the emacs users I know have a feeling for all terminology used here. Perhaps clarification text or examples could help there. Perhaps indicate up front how the results will be published?This is a nice framework!Great platform and questionsFix multi threading pleaseSome text fields could be made biggerLooks great. Keep up the good work.Less requiredIt's good, thanks!Can remove some of the questions by checking the already replied. If I say I didn't have any knowledge of programming I can't be contributing to the source code. (not in my case but it can be useful to consider.)seems like a few nationalities have errors, for example cape verdean and central african seem to have been split into separate optionsEverything works great and is straightforward!I don’t create to emacs package and there wasn’t an option for that. I would like to, just don’t have time.In a lot of places the answer was just "Github". I think it should be more broad in that aspect.There could be a button for "no educational level attained" or "Graduated primary school".Awesome that I can fill this out with JavaScript disabled!Yeah, it was fun and interesting to go through and learn about the questions (and my answers :) There are two questions that I didn’t know how to select : 1. How well does Emacs perform in your experience? Very well, it's snappy Good but not great Alright ... The gap between "very well" and "good but not great" seemed big to me. I would have said "Great, but there are some itches", I could not say "it’s good not great", but I could not say "very well", either without mentionning the itches. 2. What is your level of Elisp proficiency? No knowledge I can copy-paste and tweak some code I can read and understand most Elisp programmes I can write simple functions ... Actuallly, I can write simple functions, but it’s quite new that I can read deeper the ELisp programmes, and I would not say I can read them and understand them easily. I would have inverted the two options, if they are, as I suppose, increasing in level. Thank you for doing this, and good fetching of the results, I look forward what will come from it :)keep good work goingSome required questions could be optional.Amazing interface! Simple, to the point. Curious about the motivation for choosing questions.Please add a box for general feedback on EMACS. I learnt to use TECO in the early 1980s on VAX/VMS. I can’t remember if I used the TECO macros which became EMACS. I found microEMACS tedious (Ctrl/X and what? Which is the meta key?) and switched to vi on NetBSD and RedHat Linux then FreeBSD. My collegues used Windows or MacOS. FreeBSD was my daily driver at work for many years until I switched to MacOS X (Tiger) and felt very comfortable in Terminal with vim easy to use. Only after seeing org-mode in use five years ago did I go back to EMACS knowing I could use evil.There were a couple of multiple choice questions where none of the option were appropriate. "What contributions do you make to packages you use?" for example. I have never made any contributions. I have considered proposing some of my modifications but they are definitely not "production" grade. I would call them "personal hacks that work for me" but I have little confidence they will work in the wild. I simply do not have the skill set for such changes.Collecting a dump of package lists or something similar from those willing might be useful.I think the above question is meant to say “Did you respond to the 2021 Emacs survey”? Answer is yes either wayI prefer region of residence over nationality ;-)too longToo many required responses w/o “Don’t know” or “Inapplicable” options. Also, I seem to recall that previously, one could select Debian Stable as the version of Emacs that I use, which is more accurate than the specific version.I started writing a lot in the small boxes. Maybe they could be automatically expanding or manually expanded. I copy-pasted to Emacs to write out my answer when it got too long. It's fantastic that this site works in the Tor Browser without Javascript. Even going between pages the answers are saved (is that because of the "uid" in the URL?).Ask more questions!, more than willing to answer.Cheers, thanks for pollingI think surveys are a great way to get feedback and I support it!One question required an answer that shouldn't've (what do you do when you find a new package), since I don't do any of the 4 options. Wording of "have a clear preference for free/libre software and am willing to accept any lack of features or UI polish" is confusing. At first read I thought that was saying what the later "limited" option was saying. (I read "any" as meaning "some, rather than none" instead of meaning "unlimited")The click area to select an item goes for the full line, including the blank line at right of the selection. Pressing there re-select my previous choice.:)I have no idea what undo and selection pacakes are. I'll google them up but maybe I'm not alone. Links could help people to become more proficient with emacs for these and other cases.Thank you for taking the time to run the survey.Would be nice if it started with a clear statement of its goals and links to privacy noticesIt was smooth. Oh wait, you did it yourself? :) I thought it's Google Forms or something. Good, clean and fast. :)Keep up the good work! Hope I could contribute in the future.iirc replies to several questions are required, e. g. question on which program language you use with emacs, and there's no answer 'none' when sometimes ppl might use emacs just for proseLove it, eager to see the results. Could we have back the questions regarding the most used packages?Ask about what parts of Emacs are lacking or need more work, e.g. Performance, Startup time, ...I learned a lot from this survey. Now I want to look into undo packages, spell-checkers, selection packages and project maintainers, not to mention how to find the name of my theme. Now I want to check out the themes listed in the survey too, but I forgot their names already. But... Thanks!Excellent work, congratulations!It might be nice to have a pdf of the survey. (It seems to point to lots of interesting things.)The US nationality is listed as "American" between "Tuvaluan" and "Ugandan". Nice joke.this can appear in org-mode. everything should appear in one page( outline enabled). something like org-mode online documentationAm I early for the 2023 feedback.Perform the survey more often, or make the survey and its answers available all the timePlease add the xmpp emacs room as a choice too :)Keep it up! It's a great surveyYou should allow no answer on any question the user once, or at least a negative option if the question doesn't applyI find it very long.Thank You!Thanks for your work!Thanks for doing it! It's perfect!please do it again in a few yearsThere was no option under the FSF paperwork question for having considered signing the papers but actively decided against itKeep it up.Questions which list "Starter kit default" should generally also let you select multiple options, in case it is relevant/you know what you are using/multiple are applicable.It defaults to a dark theme for me on iOS, whereas light/white theme is standard and easier to read.Thanks for all the fishLongSome multi-select are difficult with only one custom answer. e.g. which theme(s) do I use? I cycle through several, so would be nice to list them. Or, which shell? I selected "I don't" and "eshell" meaning that I rarely use a shell in Emacs, but if I do, I'll use eshell.Some question could be nested - if top questions is false, then no further questions need to be displayedIt crashed on firefox mobile, multiple times.Participant could be asked whether they use other editors as well alongside Emacs and, if yes, why they do so.1. Change "nationality" to "nation or region". 2. I don't think "Puerto" and "Rican" are two nationalities, maybe it's "Puerto Rican"?i'd love to learn more packages. and how to install at home. most i use are on my bsd shell isp.Great survey, great questions.Mandatory questions have noisy answers if none of the above actually applyLooks and works great, kudos.I can't enter 0.5 as years.Add a field for freeform commentsSome question options too limited, I can't recall my emacs version off the top of my headThanks for not using JS for a survey!Everything is great but the the nationality selector is terrible. "American" should be "United States of America", as is standard. It also seemed to be issues with the alphabetical sorting. On the other hand, good job on the "gender" input. So many surveys get this wrong.Inspirational. How eMacs used, and what it supports. Survey itself seemed inclusive, clear, efficient.Was good :)It's always a pleasure to share any information about emacs. I hope it's useful to you.Very hard to use in eww.allow people to quit half way! some answers better than no answers; survey should be even shorter; make more of the questions optional;checkboxes that must be checked are evilSee if people have used multiple key binding strategies in the past and what they are using currently. Ex I have lots of experiences with Emacs bindings and some with evil-vi and meow and little with xah-fly keys and very little with boon. I currently use Emacs bindings with meow sporadically.The rationale of some of the questions are not clear to meSome options like Github go in detriment of other Git resources. I.e. there's a potential bias generated when the list of options suggests a subset of possibilities.Crafted, Prelude, and Purcell all belong in the starter kit section.Continue good work. Emacs is great tool.There was no opportunity to express areas of difficulty with emacs. Specifically in my case, as a Python developer I regularly have to reach for VSCode for things like debugging, deep code exploration or live-linting. The existing Python packages don't work well out of the box and I wasn't able to use online resources to get them working in a reasonable amount of time.Hope it's of some use : )Warn users you’re limiting a response to 10 items before admonishing them. Also it should allow for submitting more than 10 if submitted again.All good~ProbablyGood choice on the Emacs purple!some repetitionNeed more sane defaults. Modern features, books, videosI am still finding out which packages to use for my daily usage. I think IDE-features (lsp/eglot and completion) should be part of core emacs, in order to be more attractive for new users.I'm a high school dropout, but selected "high school" as highest level completed since that was the closest option. It took me a while to find "American" as nationality since I was trying to autocomplete "United States" and "USA."It's a great survey, covered many aspect of Emacs. I wish I came to know about the survey sooner and through some other way medium.Many people work in more than one industry. American is an ambiguous designation and hard to find when looking for the united statesI didn’t have an answer for some mandatory questionsThank youA couple more questions about the weak points of Emacs could have been also useful. Also, it would be really interesting to have a visual comparison of the results of last years' survey. Thanks to everyone working on realizing this survey, but maybe Julia is a bit of a niche language for reusing this code for another purpose :)A separate mailing list option to be pinged directly by email for updates. Though, I can see how that might be hard to anonymize.Compared to other modern editors like VS Code, Emacs lacks snappiness. Code completion struggles frequently. I would love to see Emacs, snappy and modern.Seems to work well! There were a couple of questions that required an answer when I didn't feel selecting anything was appropriate (how do you hear about new packages, etc.).For the question about how long you have used Emacs, there should be an option for less than a year. I have only very recently started learning how to use it, and am probably not alone.I can get you a business account on Typeform (supports open Source) for such survey in the future. Just ask. hubert.behaghel@typeform.comGreat improvements on survey form layout, as well as questions asked. Keep it up! :-)I actually live in emacs... I might switch to vscode one day (if it will be able to do what I want)It would be interesting to ask if one does soley use emacs or also other editors.You should specify how many favorite packages before I listed them (i.e. max. 10). It would have saved some time. Very happy to see a Javascript free survey.No :)The survey is very oriented towards software development. You should also ask questions about languages such as French, Chinese, etc. Maybe let the survey be localised as well; I think I've read that there is an Emacs community in Japan, and they'd be more likely to respond to a Japanese version of the survey.I wanted to write more on my first impressions of using emacs 10 years ago and suggestions for making it better for new people now. Did not know there was a word limit. Typed it all out only to find it was limited to 400 words. Time was wasted. If there is a limit on words would be helpful to know this upfrontNice work. Thank youI love the UI on this survey. Really clean and pleasant.I’m happy that you are doing it.For the survey platform, you cannot "uncheck" radio buttons even if the associated question is optional. As for the contents, a bunch of questions seem to lack a "no" answer. (or something along the lines of that, depending on the question)I just use emacs for org-mode. The survey asks about a lot of stuff I don't care about.Nice UIThank you for preparing this survey system!One of the smoother survey experiences. Oftentimes taking surveys I'll get bothered in the middle but there weren't any issues.Is it actually taken into account by FSF? and acted upon? If not then it's pointless.I don't know what version of emacs I use so please make "don't know" an option - am away from my computerThank for your time to create this and the analisis you provide at the end.Some of the questions frame things IMO incorrectly: - I use mostly standard keybindings but with a lot of weird customizations, many of which would throw off almost anyone else initially; there was no answer to reflect this - It is not possible for people with multiple citizenships to answer correctlyAge should be a range. Specific age is too identifying.appreciate it's very simple (design) and fastThe result shows everything is missing, have no idea if it submitted my answersI'm new to emacs, so many questions do not apply. An option to answer, "I don't now but may in the future.' would be more appropriate.You should be more clear about what you mean when you say "packages" (Emacs packages? OS packages? Packages I build myself?). A couple more questions about modernization and approachability would be welcome: 1. What would make Emacs more useful to you (a GUI that matches the going modern GUIs would be one answer)? 2. Is there some use-case Emacs should more strongly pursue?There was an entire page about Packages that had required responses, none of which were "I don't f*ing use packages", which I suspect applies to a great many emacs users (the ones who use emacs only by running "emacs file.txt" on the command line, where file.txt is never .emacsrc)Don't have mandatory fieldsIt would be useful to ask about most common annoyances (window management is mine).The survey is oriented towards active users of Emacs. I was a heavy user 5 years ago or so, but since switched to IntelliJ and then VS Code, and there were few questions, relevant for me.I think the 'industry' question was a bit weird, was it meant to ask about my profession or my employer's field of business? The company I work for is a retail company, but I do software development there as our product is a web application.Thank you very much for putting this up!Don’t make all answers mandatory. Otherwise, thank you for your great work🙏🏻Emacs tutorials and deep dives for new users are scatterd and sometimes out of date. Itd be good if the emacs community had a @cursted@ set of consistent emacs tutorials. Cat herding problem I know, but this is the appeal of Visual Studio Code - far better managed due to $$Great survey!I would have liked to select multiple previous editors as emacs replaces my previous plain text editor and previous ide in parts.Every free/libre tool i use usually have better ux and or better features then the alternativeI like it, the questions are well formulated and the proposed answers are comprehensive.I wish I could have listed more favourite packages! ;)Demographic page needs more work - i.e. opt out from age/gender questions, multiple nationalities selection etc is the survey platform libre? question about UI polish and foss preference is confusingworks fluently. Good job.Emacs is such a great software, let's keep it that wayIt didn't work in eww (GNU Emacs 28.1 (build 2, x86_64-unknown-freebsd12.3, cairo version 1.17.4) of 2022-04-12) - I got half-way through the first page and then things got janky, with text overwriting other text.I just wanna once more reiterate how awesome straight.el is. It has made it so much easier to contribute to packages.Some questions seems to be asked multiple times.Make some of the mandatory questions optional / or have a "prefer not to answer" / "not relevant" answer. For example on 'how do you reach out for help': I just stop using the feature / package or google. I don't reach out to devsthank you for this community service <3"What languages do I code in" question could not be empty. I don't use Emacs for code at the moment.good you do itSurvey works perfect on my end. Thanks for setting this up and running it! :)👍Love what you’re doing. Can’t wait to see the results!Selection in the text fields is broken for me. It's not visible when text is selected.A+It's fine, but it's hard to answer some questions without my having emacs open currently.Keep up the good work. I look forward to seeing the results.Allow multiple options for the "previous editors" question.Page 5 keeps crashing on firefox Android, so I had to continue on my computer"How do you contact package maintainers?" should either be optional, or have an option for "I don't contact package maintainers"graphical browsers suckQuestion on willingness to forego features/UI polish should be separated out. I am willing to forego UI polish much more than features.You might want to limit the responses for the question "What documentation do you wish package authors would more often provide?". I want more of everything. Maybe have a priority list?It might be nice to know how people interact with programming languages, like eglot, lsp, other.Big thank you for doing that survey!Hey the nationality question seems to be broken. The list of countries isn’t in alphabetical order. I noticed that “Costa” and “Rican” show up as separate entries. I couldn’t find my country, the little known United States of America, in the list and selected “Other”.Mandatory questions about "packages" assume I know and care what a package is.There was a question about how I reacted to new packages which was mandatory, surprisingly.Long live the EMACS fraternityI don't like the required questions about how I use packages and how I communicate with package owners. I don't really do either these days.No, but I have sergeant feedback.I appreciate the optionality of javascript on this page.
Do you use a spell checker in Emacs? Vector{String}flyspellNoispellframework defaultlangtoolspell-fuaspellhunspellwucuoflycheckHunspelllsp-grammarlygrammalecteflycheck-grammalectegrammarlywcheck-modeflyspell-correctjinxgrammalectwcheckmy phonewant tono nyt i shouldno, but i will learn flyspell soonaspell via ispelldict.el, define-wordFlymake-valelsp-ltexI use M-$, don't know what it's calledto be precise, langtool via lsp-ltexI pass. plane to use the one in Doom.flymake-valealso flyspell-prog-modenot yet, will use oneltex-ls via EglotFlycheck-GrammalecteI use vimgrammarly-lspHave never gotten it to workYes. Don't know wich onelibvoikkoenchant / wcheck-modeunsure, whichever is built in probably?used flyspell but had bugs with itGrammarlymainly speckflymakemacport builtin macOS dictionaryflycheck-aspellmacOS via enchant2Eglot with ltex-lsHspellI want to but had trouble setting it upCustom script for Antidoteflymake valemy owncompanymy language is not supportedaspell (with flyspell)Not yetgrammerlyI think I use ispellAspellHave not yet explored, due to lack of timeno but I willI use languagetool but the package I use is not langtool, it's languagetool...hunspell with dual pt, en dictdoomemacs (spell)macOS via hunspellNino, but want toMy reverso.elflycheck, grammalectei manually check some words with c-$ or whatever the key wasTrouble with spell checker binary on windows. Not solved. My biggest gripe with emacs on windows
What is your level of Elisp proficiency? Stringsimple functionscopy-pastewrite packageread and understandnonemany packagesunderstand internals
How did you find out about this survey? StringHacker Newsr/emacslobste.rsEmacs mailing listFriendTwitterBlog postDiscordEmacs ChinaIRCDiscourseTelegramMastodonmastodonlinux.org.rufediverseMatrixFediverseReddit4chanredditsachachua.comSacha ChuaSlackfriendEmacsConfOrg mode mailing listorg-mode mailing listEmacsConf2022Colleaguecolleaguer/orgmodeEmacs NewsOrg-mode mailing listslacklemmy.mldoom emacsorgmode mailing listDoom DiscourseWork SlackgoogleSacha Chua newsletterXMPPLemmyunitedbsd.comlemmyEmacs newsworkSacha's Emacs NewsmatrixInternetemacsconfOrg mailing listhttps://planet.emacslife.com/Work Slack channelWork4chan /g/Emacsconfycombinatordoom emacs discourse#emacs:matrix.orgemacs newsorg mailing listhttps://discourse.doomemacs.org/t/emacs-user-survey-2022/3331planet.emacslife.comDoom emacs discoursework slackSacha chuaSlack at my workplacehttps://zzzchan.xyz/tech/thread/5022.html#7333!emacs@lemmy.mlCompany Emacs groupPlanet EmacslifeSacha Chua's blogNubank's company slackmastodon (via: https://post.hillenius.net/notice/95501 )My company's emacs slack channelYoutubesearchCompany internal emacs slack channelOnlyfansemacs-jp SlackSascha CY’s Emacs newsfediI use vimSacha Chua Emacs news mailling listEmacs News Sacha ChuaDoom#emacs channel in our Slack space at workMumdoomemacs discourseI have already forgotten what I clicked to get here.Fuzzing WgetDoom emacs communityFrinedly Lisp and Emacs Thread on 4chan.org/g/Japanese community on SlackAlready forgotInternal forum at workSacha Chua - Emacs Newsr/org-modeMastodon.social, in particular https://graz.social/@publicvoit/109227491904170985coworkerCompany's emacs Slack ChannelEmacsconf 2022forums.freebsd.orgemgWork slack channel for emacsWeChat/E/programmingInternal work slackWork colleagueLocalssearching web for Emacs user statsWanted to show a friend last survey and discovered thiswork Slack:doom discoursepeople at work mentioned itColleguehacker news (ycombinator)Slack communityFreebsd forumDoom-Emacs' DiscourseEmacs conf 2022SchemeBBSemacs-china.orgWork emacs chatThe Julia Zulip@publicvoit@graz.social mastodon postFriendsemacsconf 2022 websitehttps://sachachua.com/blog/category/emacs-news/Company SlackSlack (emacs-jp)Sacha Chua RSS feedmvp slackMy Emacs old buddyorg mode mailing listDoom DiscordMastodon/fosstodongoogled emacs newsMastodon tootSacha Chua's emacs newsWebI randomly found it on a web search and remembered the previous oneFriend at workpigeons & rats, also ducks & geesea link on a site that I forget as this was the only interesting Emacs stuff on it for meEmacs Newsletterhttps://emacs-jp.slack.comnixos matrixLinkedInmatrix channelFosstodonPlanet EmacsliefWebsiteEmacs JP Slack channelDoomemacs home pageFfsEmacsConf2022 Talkdoomemacs discordfosstodonNix Emacs channel on MatrixRSE SlackCoworkersImage BoardsCoworker shared itMastodon (fediverse)mastodon (fosstodon)Sacha Chua's Emacs newsOrg-mode Matrix roomboardmastodon #emacs tagWork slackslack emacs-jpSacha Chua's blog pageSlack channelForum postSlack workspace: emacs-jpBoyfriendSearch engine of my choice4chan /g/ emacs threadMastodon/FediverseMastodon / Fediverse postsDoom Emacs discordCoworkerpost on forum linux.org.ruJapanese community in slackhttps://news.ycombinator.com/item?id=33328142Colleague on internal chatroomzatech slack communitySearch hitSacha's blogmastodon postsoylentnews.orgMeemacs-chinaFosstodon postSlack channel at workby chance, web searching for emacs configurationWeb SearchDoom Emacs Discourseinternal company communicationhttps://www.unitedbsd.com/d/947-emacs-user-survey-2022Sascha Chua's emacs newsletterdiscourse.doomemacs.orgWork Slack groupActivityPub/MastodonxXmppImageboard threadFatherCompany emacs GHC group@vedang@fosstodon.orgDoom emacs documentationFreeBSD forumI Google'd itweb searchInternal company messaging boardinternal slackfrom a mastodon postThe author :)my company's slackTelegram Emacs StoriesLinux.org.ruslack channelMastodon/ActivitypubMy framework's discourseCompany chat roomDoom discourseScheme BBSLORLunduke locals postN/AReddit and/or mailing listMastodon, FediversewebEmacsConf streamstumbled across it.friendsCompany Slack channelI accidentally found it on googleidunnoxmpp muc (xmpp:emacs@salas.suchat.org?join)Emacs news :: Sacha Chuaone rss, not sureCompany's SlackJabberhttps://lists.gnu.org/archive/html/emacs-orgmode/2022-10/msg00832.htmlemacs.confcolleaguesFreeBSD forumsMastodontFacebookPlanet EmacsLifeHackerNews through telega - one of my preferred packages...Sacha's Weekly Newsemacs-news (Sacha Chua)Japanese Emacs CommunityFrom my programming language community (Julialang's Zulip)SachaChuahacker newdPlanet Emacs, Sasha ChuaSacha Chua's awesome blog!Mastadondoom emacs discordimageboardsa post by a user on my self-hosted NNTP serverdoom discordhttps://www.linux.org.ruEmacsConf 2022eattherich.clubinternal company chatcompany slackMastodon postDoom emacs newsSacha Chua: 2022-10-24 Emacs newsEmacsConf and Emacs hangouts YouTube channelWork's Community@recurse.socialGnus and news.gmane.ioSacha Chua 2022-11-07 Emacs newsGoogleRSSHahaha. Mastodonemacs conference talk about it... :-DFediverse postFriend sent meproject-mage.orghttps://sachachua.com
How old are you? Integer354030323733343828312925273642392641222324454344215020484649475152195553185456575860176159166366656462681567701469711211777672731397494
Do you contribute financially to Emacs development (via the FSF) StringNoI have in the pastWould directlyCannotYesI shouldI will in the futureHELL NO!!!I intend toWould if there was a bounty systemI wasn't aware of that possibilityNot yet.indirectlyI should. I want to.FSF associate membershipI didn't really know that was an optionYes if FSF membership counts.planningI have in the past, but the restoration of Stallman has depressed me and I stopped.Would like a stream line way to donate directly to the framework's maintainer and Emacs.I could if it was easy. (I dislike paypal etc.)donate to FSFE (in Europe)In conferences (FOSDEM)No, but I probably shouldWait 'til I get my money right, then you can't tell me nothing, right?If I continue to use Emacs I will contributeNever crossed my mind to be honestI may be ignorant but it is difficult for me to see any "official" way og doing that - a la Wikipedia asking for donations.I would like tomonthly FSFEI use vimNo, but probably will soonI plan to buy the Emacs Deluxe package from the FSF shop soon.I would like to in 2022No, but I probably should. Feeling guilty now.I want to buy the Emacs Lisp book and other Emacs effects from the FSF, but the FSF is out of stockI would love something I can expense at work (eg: Sublime Text license)I had never even considered it as an optionI didn't think about it. good ideato the FSFENever heard of FSFbitcoin onlyHave not thought about it yet, am not opposed to itI would like to donate in EuropeI have contributed to the FSF but not emacs directly.I'd like toI haven't considered it but will do so nowNo, but I would like to in the futureNo but would be willing toI've donated to the FSF via BrightFunds and my employer matched my contributionI have no idea howSoon(tm)Not sure: not recently anywayconsidering itNot yet, but I will at some point.I would like to, but I don't know howI don't know FSF.am FSF memberdidn't know it was possibleintend to do soI should, but always postpone, sorry (donating from outside the USA isn't straightforward)Not yetI would if they accept via westernunion or moneygramI did in the past, but I find the FSF's other activities to very little value added (for me) beyond Emacs, GCC, and a few other projectsMake it easyNot at the presentI plan to in the futureI am planning toBought cups.I donate to FSFI was unaware of thisNot yet!I’ve been considering itI would like to buy merchandise if it would look betterI will not donate to the FSFI rarely buy stickers, t-shorts etc from GNU storeYes, but I would also like to donate to Emacs directlyI plan to soonI buy things from the GNU store, including emacs-related productsI contribute to the FSF but not directly to EmacsThe fact that FSF would reelect Stallman after his disgusting positions on sexual abuse of children and pattern of sexually abusive actions toward women ensure that I will never contribute to the FSF until it cleans house.I didn't know about it, but will considerdirect to maintainers. FSF, itself, is too extremist to support.I have an FSF membershipFSF Assoc MemberI've donated to org mode previously
What contributions do you make to packages you use? Vector{String}IssuesAdvocacyCode (bug fixes)Code (features)Documentation
How strongly do the ideals of free/libre software affect your computer use? Stringmoderate comprimisesignificant comprimiselimited comprimiseany comprimisedo not preferno comprimise
How often do you use Tramp? StringNeverRarelySometimesFrequentlyOften
What documentation do you wish package authors would more often provide? Vector{String}TutorialsOverviewScreenshotsManualComparisonDesign rationaleClips/videosn/anoneExamplesexamplesN/ANoneusage examples.NADon't careNever thought about itI don'tI don't knowUsage examples?examples of useExample configurationFAQsREADMEJus a readme is fineDon't know. Haven't read any recently after I managed to do what I wanted to.Commentary text near the top of .el files.Usage examples and rationales.docs are mostly okexample invocation of functionsInitial installation and basic config instructionsInterpretive danceSpecific how-toscode commentsSource code documentationCustomization options and keybindingssample configsA few working examplesExample usageScreenshots. Seriously. Just need to stress this the second time.It may be text-based but they're incredibly helpful.known bugs/limitationsREADME.mdSoftware architectural overview, docstringssome way to list existing keyboard shortcutsDocstringsno ideaexample of usagesDunnoI use vimDon't knowThis question is kind of weird... But I can tell you what I DO NOT wish: animated gifs, clips/videos.Benefits, and recommended setup/use. If they described why they made it and how they use it that could convey a lot to the potential user.didn't you say these questions were optional?Examples, for typical use casesInstall documentation :(if there are many alternatives I want to know what the differences are for the particular one, otherwise a quick tutorial is very helpfulnothing special (this question probably should've been optional)concrete examplesmore examplesconfiguration howtonull answerconfiguration samplesI don't even know what a package is.shortdocnothingsource code commentsSimple, plain manpageHow 2 install stuffWhat problem was solved that could not be solved without itI fucking hate animated gifs of screensproper reference manualLists of keybindings and detailed customizing interfaceConfiguration adviceMinimum viable example Elisp code, runnable starting from "emacs -Q", ideally.Examples in documentation/infoI find all I needA detailed referencedo you want any input at allWhatever is appropriate and more than the barest minimum. Almost any doc is better than a bare ELPA paragraphInteractive documentation like the doom emacs init module would be incredible.sane default config configGood question. Nothing specific comes to mind.A websiteexamples and common use casesExamples, examples, examplesExample use-package declarationsSatisfiedStop assuming use-package.do not knowThe level the package works at, is it a backend, front-end, etc. Be more specific, on different use cases, being also clearer if it works in TUI or notGraduated intro: starting out, more features, customization, deep hair,....Terminal noxNone of the aboveHaven't looked into many packages yet, so I can't make an informed opinion.symbol naming conventionsNone of the above, the documentation is usually fineI honestly don't read documentation often. I read the elisp source to figure out how packages work.List of commands and variablescode samples for everything!SCREENSHOTS! Not enough of these…basic install processNo idea.i don't knowI'm generally very happy with package documentationDocs are finecommitmentgenerally fineComment their code. I want examples in the comments of at all possible.plain-text doc (e.g., Commentary)multiple examples of configurationtheir testsNo wishes/did not think about itOnline manualI don't know.No problem:shrug:example configurationsinteractions with the ecosystemI don't think I can give a general answer here; it's fundamentally a case-by-case situationa concise READMEDocumentation about the mental models of a package, see ESR's post on "narrative documentation"Design rationale and gifs for how to use package are mostly essentialCode snippetsNothing comes to mindMusic songsConfiguration knobs referencehow to set basic package settings for people who do *not* use use-packageShort GIFsNone; most is goodInfo Manual above alldefault/recommended keybindings, variables available for customizationidkWhat the maintainer sees fitI read the source as needed.List of configuration variablesComprehensive configuration examples and descriptionShort demo of how to actually do the 3-5 main things the package can do.Plain simple EXAMPLESopinionated settings that make senseexamples for customizationDocumentation is often greatExamples of real world applicationsBeginner-friendly configEXAMPLES OF USEDetails on extending the package / or user storiesSetup/Debuggingdon’t care(dummy answer)Common work flowssetupin code commentsExample code snippets.tl;dr and main functionsmore explicit comments in code so i can more easily navigate and change behaviorsinternals overviewpackage authors are doing a good job alreadyAnything that tells the mode name of packages that install modesConcise description of its purposeI’m happy with the docs usuallyQuick start, then detailed configuration.Sorry authors. I wish they did, but I am not askingdocumentation is great as it isDocumentation is usually sufficient for packages.Reference manual with examples for all featuresdepends on the packagehaven't consideredim not missing anythingShort getting started section with sane defaultsExamples on how to use correctlyNothingDocumentation of the configuration (available keys, values, what they do etc.)Getting started (config example, most important key bindings)Configuration optionsHigh quality code, excessive unit testing, tell me what files/directories/settings/urls/etc. you are going to violate and abuse, are you going to be accountable for maintaining this code, etc.I don't really wish thisA comprehensive list (and explanation of) interactive functions, intended-public functions, and keymaps (defined or modified).I find most documentation to be more than adequate.Docstrings (or whatever they're called in elisp) for a package's functionsconfiguration examplesI would need to know what packages are in order to want information from their authors.better installation instructions. don't assume i know how to set all the options - even if you give me a detailed description of what the function does. Look at the nano theme instructions - i talks a lot about the dark mode theme, but no where does it explicitly say how to activate it from a copy and paste perspective.why us asking when I said I don't careWorkflowsSample configurations e.g. for use-pacakgequickstart (short tutorial), just show me the basics quicklycode examplesanimated screenshotI have found package documentation to be generally pretty good.Tutorials over common work flows. It took a long time until I saw the point of org-mode for example. On the surface it looks so trivial.Definitely not an info manualDocs are generally fine.Typically I think package documentation/quality is quite high.Few packages state the goals of the package, my idea of what the name implies is often not the same as the authors. Or at least what the package is capable of, there is way too much dissappointment when trying Emacs packagesinformation per operating systemI am pretty happy with what I getI really appreciate it when someone shares the workflow they use when using their package.I wish there were more configuration examples (*cough* transient *cough*)regular manual page -- *NOT* infopage, pleaseintroduction per blogposthow to install manuallya simple README.mdInternals/HackingN/A - I normally find the documentation to be good enough for me.Any appropriate example of how to useeUsuage scenarios with configuration examplesInstallation Guideno opinionDocs are goodnot sureinfomercialsdeeper documentationShortcomingsStrictly more explicity manuals, e.g. consistently stating the working file or directory especially with packages that rely on multiple dependencies.Decent API documentationdon't knowcode examples in the documentationProofs. How to interact and configure the interactions. How to make smaller circles.Interactive tutorials inside of Emacs! Software should teach us how to use it.I have no complaintsExample configurationsWorkflow for testing and contributing changesnothing reallyNothing especiallynone ("must be answered", so...)honestly if they don't provide what I need I don't use itI don't think there's a consistent failingThey do a good job.Every documentation is good, though most important for me is a quick demo from how to install to how to use main features.Code examplesRecommended configurationnever had an issueGood Examples with options not just the simplestWindows compatibilitya texinfo files, always!elisp is often auto documentinghappyDon't know what a package isman pageyoutube tutorialcommented functionsQuick example usagesWell documented commands (docstrings)Examples of usagedon't know. please stop making mandatory questions if you want the survey completed.I have no such wishesShortdoc entriesThe more the merrier. Anything helpsComprehensive description of all of the toggles and options!(use-package) configuration exampleGenerally find documentation OKPLEASE SCREENSHOTS if not videos!!!README.md / README.orgIt is fine as it isfrequently used functions and variablesConfiguration settingsany/don't carestability and dependency guaranteesReference of configuration variables and how to extend or override functionality.Commented out examplesvalid elisp I can eval, or the M-x equivelentI find packages generally to have excellent documentation compared to my expectationsworking examplesExamples, small demosDefault keybindings should always be optional (i.e., no default bindings should be possible)Deprecation notice if no longer activeConfiguration exampleGenerally happy w docsnilwhy am I required to answer this question?Complete description of flags/settingsExample configurations.I do not use packages anymoreexample use-package declaration (or at least a link to MELPA etc so I can consume it via use-package)More practical configuration examplesSensible default configuration(s).one-paragraph summary of what a package doesexample workflowsContribution processworkflowSource commentsMinimal working examples e.g a vanilla installation an the package installed only and then examples of customizationThere tends to be too much documentation. More focus on package usability would fix this.I don't use third-party packagesPremade configurationsmaybe an in-emacs tutorialQuickstart for the ImpatientSimple use case examples in emacs not webA basic key configuration to get startedHigh level description of the source code repositoryANY kind of docs will help! Since the community is small, the need for good docs is even bigger. Less docs -> less users -> smaller community -> expert docs only -> getting more and more difficult to get into it emacs in generalTypical usage examplescookbook examplesExamples!UP-TO-DATE examplesInteresting/tricks and tipsNo preferenceInstallation proseI don't caremiss nothingReferenceNo opinioni don't use third-party packagesTheory of operations; can't stand the "type this, type that... see it works!" style of documentationsome packages make it kinda unclear what the package does, sometimes, using abstract metaphors instead of a pragmatic example use caseI typically find the amount of content more then adequate and the bigger issue is visibility into the docs.Explanation of data structures
Which keybindings do you use? StringEmacsVimCUAmeowMeowxah-fly-keysCustommy ownevilcustomxah fly keysBoongod-modeMy ownXah Fly Keysspacemacsboon-modeKakounemineergoemacsRYO Modaldoom emacsCompletely custom evil bindingsboonHybridBoth Emacs and VIn/aevil with emacs keybindings in insert statevim & emacsHeavily customized defaultsXah-Fly-KeysMix of evil and emacs bindingsi'm the keyboard commando bitchdoom emacs evil modeUse hydra to do my own based on macOSSome default, some my ownWakib-keys (includes CUA)Mix of default and custom ergonomic focused one via meow.elXah Fly Keys. It's THE FUCKING GREATESTI just use the F10 menu bar.DoomHybrid/CustomNoneDefault and modal via BoonMy own keybindsI used the default, until I tried evil-mode. Then, I switched to VimHybrid (evil + emacs bindings when insert mode)Xah fly keysDefault with many custom bindingsCustom ijkl basedI have my own modal modeCustom via ryo-modalGutted defaults quite a bitAquamacsEvil/Spacemacsmostly spacemacs defaults plus CUADefault+MeowDefault, but I wish CUA was better (for example CUA has problems with keyboard macros)Custom vim on custom Colemak on split keyboard (ZSA Moonlander)Custom, CUA inspiredDeeply customizeddoom's spacemacs adaptionCompletely custom using ryo-modalDoom (not evil) + custom to make it feel more like macosHybirdTPUcustomize for Dvorak htnsbfVim + Emacs in Insert modemostly default with a few mods to make using with MS Windows easierMy own, CUA++Meow, kinda vimishDefault + M-i and M-k for scroll-down/updefault + my ownEmacs and vim sometimesI don'tmostly default, but customized (partly CUA style)Evilmy own ryo-modal-mode setupSpacemacs HolySet it up myselfErgoemacscustom, cua-likeCUA + tons of custom bindsi dont use emacsDefault with god-modeboth default and vimhttps://github.com/hrehfeld/beyondEmacs PreludeI don't knowDefault + MeownoneCompletely customI switch back and forth from the default Emacs keybindings to the ones provided by the meow package.Vim & Emacsdefault + custom keybindingsBoth default Emacs & CUA (Yes, that does work!)meow-dvorakhybrid (Spacemacs)Xah-FlyDefault with extensive customization.Default + macOSemacs+evilown based on ergoemacsHeavily customized vim-likeVim + EmacsHomegrownFly keysPartly defaults with plenty of my own keybindsBoth Default and VimasdfVery heavy customizationDoom emacs but using C- and M- etc not the Vim bindingscustom + evil + no emacs defaultsDefault + macOS shortcutsMainly default (but with C-z and C-o as prefix keys)Vim, but if i find verb+subject keybindings, i will swap to thathighly customizeddoomQWERTYcustom vim-likemy own custom keybindingsvim and EmacsCustom Configuration (CUA Based)my special keybindingssMacOS + Mine via hydraVery customizedI do use VimHeavily tweakedAll combinedmix of doom (not evil mode) and default emacsDoom defaultsdefault + meowMine, ex Vimmer who prever single key/single key+modifiers for anythingCustom vim like bindings with additional modificationsi,j,k,l to move the cursorDoom EmacsTweaked defaultsCustom modal with ryo-modalSignificantly customizedmeow.el, with additional hyper bindings using caps lock keymix of custom and defaultSpacemacs emacs styleI've rebound most bindings.custom modalXah-fly-keyshybrid vim/emacsDefault + lots of customizationDefault+customModified Defaultmix of CUA, default, and some customisations to feel more like macOScustom, with some defaultheavily customized/changed defaultsVim and Emacs bindings mixedMostly default, with a few custom ones (e.g., C-h is backspace).Totally custom keymappingsEVILdefault and cuadefault + CUADefault + HydrasDefault + Prelude.el on topDefault with much customizationhybrid vim-emacsCustom modal bindings (using modalka)I modified default Emacs bindings based on my preferenceDefault and Ryo-modalDoom Emacs (vim + spacemacs)CUA + my ownslightly altered defaultHybrid Vim and EmacsI use evil-mode with Emacs bindings in insert-state.doom emacs vim hybridDefault with custom prefix and bindingsmeow + Defaultcustom keys with meowCustom modal (based on Xah-fly-keys)vim normal mode, insert mode as emacs modeModalkaDefault or evil, depends.Highly customized (non-modal)ownDefault Emacs and personnal (hydra/transient) onesall customemacs + vimModalka.el / custom modalDevilAquamacs (Default +macOS keys)I just use the menu bar.Own vi likedoom evilCustom for dvorakAllmix plus user-defined key -bindingsCUA + default + some tweaksCustomized vimMostly defaultboth vim and emacs bindingsevil + emacs in insert modeMy own customizations. Many keybindings come from previous editors for which I developed muscle memory.slightly modified default bindingsMeow/defaultcustom Vim likeemacs+vimVim exclusively for when I'm editing a file, but vanilla for all other thingsDefault, Vim, CUAblend of private and defaultEmacs with JOVE-like changesEmacs / Vim ComboOriginalrolled my own after 4 years of using Evil (have lots of prior experience with ViM)Spacemacs's mnemonic vim-style bindingsmeow(another modal editing on emacs)VI for text editing, Emacs for all other aspectsEvil and defaultBrief basedEvil with Emacs in Insert stateDefault (Emacs) and Vimcustom+cuaEmacs + EvilDefault + a number of personal keybindings.onMeow.elmy own bindings for French accentsnotepaddefault bindings with pareditmeow with default keybindingscustom ergonomic keysSPC+xxArista's, plus a lot of my own key-bindingsMeow modal (different from Vim)hybrid of Vim and EmacsCustom, based on defaultsMostly default with some custom keybindingscustomized onesdefault, but some things personalizedunholy combo of custom, Vim, & Emacscustomized out the wazooVim and Emacs when insert modeEvil modified for my own version of bepocustom (vim-like, more kakoune-like)Default + rebinding forward to lMix of Hydra + default EmacsPreludeEmacs/Vim combomeow mixed with defaulttry to stick to default but to say I haven't any custom would be a lieUserdefined, SaneOwn direvd from defaultMeow package key bindings
Which use cases of Org Mode apply to your usage (if any)? Vector{String}Note takingTask managementGeneral document writingPKBAgendaBabelTime trackingBloggingBlognonePresentationsJournaldon't useNoneroamRoamwebsiteNovel writingDiaryWebsitepresentationsSpreadsheetsScientific writingblogexporting to html (mostly) and presentation (reveal, would like to do more of this)Presentations for reveal.jswhats org modeweb publishingBeen keeping my diary in org-mode since 2007Grocery listBeamer presentationsfilesystem management with org-roam and org-attachWriting presentation slidesPresentations (epresent)I keep track of my current goal, subgoal, and sub-subgoal in an outlineauthoring my blogI will soon try to make presentations with it, either with org-re-reveal or org-present.Academic papers and presentationsClient documentationBlogging, Record keepingtest case developmentI use vimblog creation and publishingWrite blog articles, and I hope soon also a nice Emacs (evil based) introduction tutorialnulll - never use org-modeorganizing emacs configuration fileUse it for the basis of generating documents in other formats, eg. exporting to doc, latex, etc.Book WritingJust starting to play with orgWebsite generationEverything!I prefer eev package over orgmode in many situations. The package is crypt, but has got lots of wonderful features and possibilities...I do not use Org ModeGTDI can't figure out how to use Org ModeBabel for org-mode generation (i.e auto generated docs)presentations with org-revealinvading mordor with the orc-mode forkmy config is an org fileSlidesI would like to use org mode as an outliner but I've never figured out how so I fall back to native gui tools where I can expand/collapse/drag/drop nodes in a tree by hand.Publication, PresentationsLink herdingLab notebook/machine install-config logNothing, mobile experience sucksI'd like to learn morePresentation writingMathematical (LaTeX) Writingwriting a booksystem administration (executable blocks)lectures and presentationsscientific writing (latex export)Interactive dashboards, code generationexomindCourse support, exported in Latex and HTMLportfolio managementNone; it's unreliable. I tried it ten years ago, but it had edge cases that screwed up my dataCopy-pasting valuable articles and posts in case they disappear from the Internetlatex export, blog, markdown replacement, interface with pandocWriting proseDon't use orgEverything I canProgrammable dashboardsCurrently I am not using Org-Mode, employing a combination of the NB bash script (which can be run in Eshell easily) and Markdown-Mode for similar purposesdeploy my small server (no more Ansible!)I dont but i want to learn itExport to htmlI stopped using it, I used it when I was on spacemacs in the past but I just use textfiles now.math with inline latexPublishingI don't use itI avoid modes.literate configs, for any apporg-journalHaven't started using it yet.sync with calendar/jiraLatex presentationMathematical DocumentsNo longer use org because of mobile syncingzettelkasten, habit tracking, implementing the GTD systemroam2i cant find use for org-modeIdk what this meansjira integrationProseNoterprose writingorg mode -> "target" like jira, dokuwiki, mediawiki, ...please break org upfinancial adminkeeping track of links between factlets (org-brain)Bibliography managingthe barrier for org mode is high, I have not yet learned itTable editor a la excelSystem file editingI regard it as a fancier alternative to text-mode.Spaced repetitionI have one table that I maintain in Org ModebloggingQuick & Dirty TablesemailIn the past, I have used it for time tracking as well.Linkedin postsFile management, really org-attach-ed single files or small tree copied, links to them in org-mode notes. The Way to have a graph-based storageMetrics (electricity usage, ...) and inventory (books)Anything document / knowledge relatedI wrote my thesis with it.Can’t figure org mode outdatabaseI'm the strange kid that doesn't use OrgI used to use all these use cases but Roam Research has stolen several of them.dot configscientific writingslides (org-re-reveal)Almost my entire computer-based life is a dozen org filestodo install groffWeb publishinganki cardsBeamer Presentationhttp requests with verb-modeBookmarks (via capture)Resumeorg-roamsimple spreadsheets within documentsI’ve stopped using Emacs and Org mode for most of the above.org-mode is the single _worst_ package in ALL of Emacs...literal pile of mud with garbage sprayed all over. Jesus good lord it's like over engineering had a demon child with quality-less code and that's org-mode.Check listsLearning how to properly use Org mode was my biggest desire, but due to lack of time, I never delved intoDon't use Orgmanaging referencesdon't use itExcel-like tablesWeb page generationOrg mode is so goodorgtblIt's still on my TODO list for trying, but I didn't get into it yet.Never used Org-modePhysical storage inventory, logging incidents, journalDiscovering featuresI even use it has a primary desktop. My scratch buffer is in org-mode, so I can take any notes or dispatch any babel blocks quickly.I never figured out why people love org mode so much. I don't use it.writing anki cardsemails, bookmarksOrg hugo for websiteWorking prototypes that I can be very confident no one will ever ask me to promote to production as-ishttps://github.com/mschaef/.emacs.d/blob/master/lisp/orglog.elInventory managementPresentation, BloggingWriting roleplaying books. Writing and publishing my website.citation managementspreadsheetCalendari have tried to incorporate org mode into my usage and it just never takesnever usedReading doc written in Org Mode formatCRM (customer relations management), invoicing, accountingBlog platform, Export as beamer PDFPersonal financedoom-tokyo-nightManuscripts, thesisAcademic writingLifeblog,publishingOrg mode was one of the most important new packages I started using a few years ago.presentations and writing blogsProject ManagementShellREADMEs for small projects that I put on githubAs a frontend to LaTeXNothing - org mode doesn't bother mePoor man's latexJournalingI only ever use it for tablesFictionTemplating into .plan, an xml feed, and a blog with capture templatespapersTracking reading list (finished, reading, updating, dropped...)Not really using it anymore. Markdown for note taking is enough.Paper and Slidesspread-sheetnone. I tried to use it for writing documentation or readme files, but ended up spending more time looking up how to do things than actually write documentationproject logging via org table spreadsheetsLiterate DevOpsemacs config (org-babel-load-file)Generate reveal JSWriting Websitesnot userWriting literature in my free timewritingorg-roam, org-media-noter,latex, org-roamorg-drillLiterate emacs configurationI don't use Org Mode :surprised-pikachu-face:Don't use it; it doesn't seem to match my style in any way.None, too much hypeI've never gotten into Org modeLatexWrote my Ph.D. thesis in it ( seriously)journaling, writing, poetrygenerating a static websiteEverything that can be represented as text and is consumed/written by a humanRPG character sheetsspreadsheetsTechnicsl docomument writingCalendar with org-caldavGenerating slidesCreating presentations with org-revealOutlining/mindmappingI need to use org mode!!!Presentation slidesAsset management, accounting, profilingI do not use org modeDocumentationBudget/Spreadsheetsnever have used it, but people whose opinions I respect swear by itTypesetting (with custom org->troff script)Note these are intended uses, haven't done a lotnone yetSlide decks, journalingPDF Export, HTML ExportOrg-mode is my general workhorse for scientific research (astrophysics).Life!proseWriting presentationsshopping list, goals, and habit trackingEmacs config (literate)I don't use org mode, it seems clunky to meacademic publishingControlling, Invoicingcontact management
Do you contribute to Emacs or GNU ELPA packages? StringNeverRarelySometimesFrequentlyOften
Can you recall any difficulties you faced when initially learning Emacs?

Please be as specific and concrete as your memories permit.

String
KeybindingsNoKey bindingskeybindingselispElispnononeConfigurationkey bindingsNoneLearning elispconfigurationLearning the key bindingsLearning keybindingskeyboard shortcutsKeybindsNot really-DiscoverabilityNo.too long agosteep learning curveUnderstanding emacs lispKeyboard shortcutsnot reallydifferent keybindingsKeystrokesKey bindings.remember key bindingsLearning key bindingsLearning curveLearning lispKeybindKeybindingunderstanding elispToo much to learn at the beginningLearning the keybindingsyesKeybindings.Remembering key bindingsKeychordsemacs-lispSteep learning curveNone.It was too long ago!key bindingN/ARemembering keybindingsThe key bindingsKeyboard BindingsFolding coden/aEmacs motions were difficult to learn. It wasn’t until after I started using Evil that I got hooked into EmacsPlain vanilla emacs defaults were quite a pain. I used XEmacs for a longtime as it had better graphical interface on Solaris/Motif/xwindows.Sorry, 40 years is too long agoArcane terminology ('meta key', 'kill/yank', etc), useful but opaque help system (it's simple to use the self-documenting help system once you know how, though learning it is somewhat of a challenge), disorganized/inconsistently categorized keybindings (that are also often radically different from industry standard, e.g. C-s, C-x/C-c/C-v. This could be ameliorated by a 'compatibility key', e.g. M-C-s = C-x C-s, M-C-x = C-w, M-C-v = C-y, etc)Didn't know how to use 'which-key' or 'which-function' Didn't understand Emacs terminology around frames vs buffers vs windows vs minibuffers My experience was greatly enhanced when I started using configurations with the `which-key-mode` minor mode preinstalled https://github.com/justbur/emacs-which-keyThe learning curve was pretty steep but manageable.Shell account I have has bit of Emacs version and installing Spacemacs config didn't work. I started using Doom Emacs which worked everywhere. I never figured out how to get latency/sluggishness (compared to Sublime Text) of the editor down.Lack of understanding the terminology.It was extremely difficult to get to grips with the window/buffer management model and even more so the keybindings and interface style. I needed quite a while to stop leaning on cua-mode, and longer to get familiar enough with Elisp, the debugger, and Emacs' internals to become confident in using and extending the editor. Counting a couple of false starts it took me ~1 year to realize gains in productivityTramp has been kind of hard. This is because it has trouble with my Bash promptI came from Vim. So, I found it difficult to retrain my muscle memory and adjust my expectations.Learning key chords for less common taskslearning they keybindingsA lot to learn but got off the ground fairly quickly - lots of online resource - if you think something is possible there is usually a guide to support.I started several times with the built-in tutorial, which wasted my time and made it seem as though I was never going to get anywhere so I would give up, this happened many times. I have been using CUA key bindings for 30 years, I am not going to switch to other navigation keys because whoever wrote the tutorial was of the opinion that they were morally superior. Also I know that it's supposed to be self-documenting, and it mostly is, the learning curve just felt completely insurmountable at the beginning, because I didn't know about HELM, I knew about the built-in manual but not about the ctrl-h v etc. functions, I didn't have helpful ... I don't think the resources I looked at emphasized "how to figure stuff out on your own" enough.I can get lost when buffer open and i cant jump outI found the default keybindings not to be ergonomic. Spacemacs got me into Emacs, although I have since replaced it with my own customization.Emacs keybindings if evil mode drops outLearning curve with all thé keybindings.No, but I started with Doom that really smooths a lot of the initial experience over.Misunderstanding why I have to write some Elisp to configure the editor.Keys, modes, learning what's available and built-in.The learning curve is steep. One must understand a lots of concepts, and philosophy. Window, buffer, frame , prefix key bindings. The googled documents usually pesume, that you know how to install a package, and configure it. Wherever you look, you encounter a lots of information - but ONLY for the experienced user.Learning keyboard abbreviation nomenclature convention, customising it without knowing elisp wellKey bindings that differed from Vim, and how “tabs” work compare to what I’m used to in contemporary applications.The sheer number of options and clunky nature of some of the defaults (a lot of this has improved over the last six years)Getting used to the completely different keyboard shortcuts.It is extremely different from all other editors/IDEs, yet the tutorial only goes over the fundamentals of emacs usage, without addressing any of the common questions/pitfalls a user used to some other editor will run into.From time to time I get those "wrong type argument string-p" messages and they are really off-putting for me as an (intermediate) beginner. Even if I know basics of lisp it's really hard for me to nail down what exactly is happening. These errors pop up sometimes when upgrading doom-emacs BUT also when I work on my own custom configuration.Documentation assumes you are already familiar with the concepts that the documentation is documenting.To many packages bundled with Emacs itself that do the kinda same thing, i.e. ido, fido, icomplete or skeleton, tempo... Its confusing which to use which are still supported and in which to invest time. Maybe a little less choice in default Emacs would be a good thing. Also think that some modes (UIs) can be a little more point and click, more showing than telling. What I mean by this is something like helpful mode, it has nice formatting,if you look at a mode-map variable it formats it so you can read it, and has some buttons for frequent actions(see source, set variable...). Yes you have those options in help-mode but they are a little buried and it's means a lot if you have it there right front and center so that you can do the thing that you came there to do right away and later when you have the time you can come and hit "C-h m" and explore and learn. This was meant to be the tool-bar-mode but it is a little clunky and not "modern" and out of place for Emacs where everything is done in or with buffers. I thing that many default modes can benefit from this, inserting a little common functionality inside them via links, buttons.Key combinations were difficult to remember. Startup times were an issue (it took me a few years to know of emacsclient!). Package compilations sometimes failed and the errors were far from easy to debug.I've been using vanilla Emacs extensively forThe install process was weird at first. Also m+X as well as space bar x2 is kinda weird to get use to.There's just so much Emacs... All this magic but it all seemed so far out of reach.The vocabulary of emacs was very confusing: pull, yank, kill ring. The names for the different levels like buffer, frame, window, were also confusing.The defaults are from another century. Until very recently, missing a built in LSP client. Pretty unfortunate keybindings without evil.Figuring out how to customize it, but that was also partly due to using spacemacs back then, with it's own customization paradigmsCJK font problemsAll. Elisp is definitely a great initial barrier to start hacking emacs.Keyboard control scheme (the whole C-x to do anything).The function names, prompts, etc. are inconsistent, the interface is confusing, the mouse operation is difficult to use, and the tutorial (C-h t) is poorly written.Some parts of the package being declared non-free by Debian, and thus unavailable.+ Default keybinding patterns was not obvious to me + Knowing where to start. Initial lerning curve can be steep. + More "sensible defaults" could have helped. It seems to me "many" users changes the defaults in their configuration much the same way.Navigating the "Customize" menu to find what setting I wanted to change while starting to configure vanilla Emacs. Adjusting to more self-exploratory troubleshooting vs. looking up solutions online (coming as a lifelong Windows user, recent Linux Mint dual-boot convert at home). Relearning terminology to understand Emacs' labels for things (e.g. "windows" vs. "frames" vs. "buffers") was confusing at first.Coming from Vim, learning the new key binding was hard at first.Vanilla emacs interface style is somewhat old and has many new conceptsUh not having Ctrl+C and Ctrl+V work was a big one. Just the general weirdness of the thing. It felt stubbornly arbitrarily different and backwards-looking. This was in 2002.Keybindings took a while to get used to, but after I did I was fine with them.I had difficulties to learn the default keybinding of Emacs.The keybindings being non-standard / non-CUAOrg-mode: learning how to adapt my routines and org-mode together to meet each other half-way.Too long ago to remember.It needs to bei configured and how to do it is Not obvious.Learning replacements for things that are easy in vi-like editors like ci" (replace inbetween quotes) or recording simple macros.There are many choices on the setup, key bindings, etc. which confused me at start and only convinced me to stay on vanilla emacs.A week of using Emacs makes my pinkies hurt. I should get an ergonomic keyboard.No, the built-in tutorial is easy to find and to go through.Huge amount of time spent acclimating to default keybindings for basic code editingBefore I started using straight.el, I've had issues with compatibilities between different packages — i.e. things would fall apart after an update, and I wouldn't have the skills or time to dig into the reasons. With straight.el & pinning, it's easy to revert.It took time understand the terminology and concepts of LISPInspecting key bindings. It was hard for newbie Emacs user. and there is few documentation for writing my own package (major/minor mode).Mostly I had trouble with the initial key bindings and desire for things to work like a more common editor. CUA mode helped with this until I was willing to go all-in on emacs.None, except that Gosling Emacs was presented as a reasonable competitor, which was an error that I soon corrected.Terminology. What is a buffer, what is a frame, etc. Nonstandard in todays age.Not really, the tutorial and the community helped me quite a lotThe most difficult thing was how to install package and how to keep them up to date. I finally went with straight.el.The keybindings were hard to learn at first. The lack of a proper vim like substitutionI don't really remember.batteries not included, lots of configuration need for basic IDE functionalitiesGetting stuck in some inconsistent states where the keybinds are all borked and not having any means to get back to a neutral state except restarting emacs. Emacs freezing because I had too much going on or tried to open something big. Lack of canonical paths towards achieving certain basic configuration tasks, there is no driver for community consensus so we're stuck with whatever works.Code completion was tricky to setup (there was not LSP back then).I had to do a lot of customization to make it on par with what other editors have out of the box. At the time, there was no built in package managerWeird lisää codeKeybindings. Way too many of them. The only way I got over this hurdle was to use spaced repetition SW to memorize them.very different from other popular softwareFinding the 'canonical' recommended way of doing something in my configSetting up C syntax tabbed indents (I use 4 spaces).When it was first introduced in my college curriculum I found it very difficult to learn because I was used to more graphical editors like Sublime TextPicking out a good set of packages and knowing now to customize them.struggled to remember default keybindingsWhen first using Doom Emacs, trying to squash bugs in the added complexity of the doom layer.The lack of Chinese learning materialsThe default keybindings are very hard to use and learn. which-key was essential at the beginning (Still very useful, but less so)Discoverability was a hassle in the beginning, but at that point it was much nicer than what vim offered.It wasn't easy to configure font (on Windows 98/2000-ish.)In the old times, yes. Nowadays no.Not really, since the on-board help is really nice (probably the best that exists). However, the defaults suck pretty hard. The amount of code projects like Spacemacs or Doom Emacs require to just bring something modern is ridiculous.it was a very strange experience. I couldnt even copy and paste.So long ago that I do not remember. I loved it from the word go.- alien and uncomfortable/unergonomic keyboard shortcuts - (especially on alternative layouts like Dvorak) - unclear how to configure stuff, M-x customize-variable?, edit the config file?, not everything is a variable - evil-mode is a lifesaver but it does not work in all buffers so sometimes I, for example, press HJKL to move around but Emacs does something strange that I have to figure out how to undoOddly enough, I had no trouble with Emacs and Elisp. It was so easy to define a function and use it. Quite different from my experience with Java IDEs. It took days to get a button to work there.Whenever I have to connect to a machine remotely I use vim on that machine. I find tramp fairly difficult to use.1. Mostly at work the version of emacs included are every old. 2. Configuring a decent IDE for c++. Struggling still. If I configure an IDE flto my liking it invariably becomes slow.the key bindings took a while to get used tono, because I was 15.I found the doom framework, together with online resources such as Zaiste's doomcast, to give a really good entry into the whole ecosystem, most difficulties i can recall where results of lackluster documentation of packages (!)I felt I needed to rethink how I interact with Emacs vs how I had used vim. No more C-z to run a program and get output. It was a struggle to break out of my old habits.It was difficult to get started because there was lots of different advice everywhere and hard to determine the foundational knowledge to focus on.don't rememberPackage installation but 15y agoAs a Vim user my flow bit different from others so most of the time, key bindings.Keybinds, as it was already in the 'vim' style.Remembering keybindings and lack of patience to learn other features. Not understanding how the buffer workedLearning the keyboard commands, especially traversing the info documentationIt's hard to remember all the commandsSo many.Difficult to remember keyboard shortcuts.Not all programming language major modes and packages work great out of the box, e.g. JavaScript syntax highlighting is wonky and the major mode isn't as good as VSCode.I switched from an editor that was an Emacs work-alike by default, so there was little trouble in picking up actual Emacs. I used JED for a while because it was available on university systems.Not easy to learn to tackle problem by myself because of my poor knowledge of lisp.Some terminology (windows/frames/splits/buffers). Spacemacs had a good tutorial and its mnemonic setup made it easier to find things.That was a long time ago. Mostly the challenge was learning the keyboard combinations and where to find everythingelisp is really painful, even coming from other lisps.Learning how to customise packages. Mainly , Elisp was and is my stumbling block that’s prevents me from achieving my dream Emacs setup.Pinky fingerThere is no usable documentation for Emacs, for example why is it when I open an internal buffer that all my other Centaur tabs are closed? I fail to see how Lisp is a productive use of my time, why can't I write extensions in some other language and then interface with Emacs like VS Code allows me to? Even with Doom Emacs it is insufficiently opinionated when it comes to setting up Interactive Development Environments (IDEs), either a tutorial or some meta package would be useful. I can't figure out how to use Org Mode, there is no usable tutorial and I fail to see why it is useful. How do I list buffers for a project instead of listing all buffers? Why can't Emacs have the content of all open buffers like VS Code and Sublime Text does, and then restore on startup? This is an important feature for me.keybindings, how to read manualGrokking Elisp, finding golden path of configurationGetting a maintainable configuration framework.Yes, at the beginning I didn't understand how to search for documentation. That meant some time spent in search engines trying the find the configuration options. For example I didn't know how the Customization Interfaced worked, and the READMEs of the package I was using didn't explain it (and that is fine, is not their responsibility to explain such basic things). It wasn't until I started using my own vanilla configuration that I understood how a lot of things worked.Keybindings, basic concepts such as navigation and termsNo in-person guidance when you need them. Took me at least 6 months more time to become comfortable with lisp.Can't figure out how to make a theme to load (turns out they have a different load path)- Creating a config file. Without a custom config, the editor isn't very useful. - Learning the key-bindingsConfiguration options hard to find and the words used to describe them not matching what modern users expect (e.g. kill/yank)Elisp has a lot of ad-hoc aspects influenced by Emacs's features ("buffer-oriented programming", global regex state) that are hard to keep in one's head when writing programs. Even the language's "primitives" are hard to remember consistently (e.g. all the ways to set a variable, all the ways to test for equality, which list operations happen in-place vs return a new value).it takes alot of time to get used to it and get the right packages unlike in vim, also learning all of the ways to write stuff in markdown and integrate packages into my workflow is awkward, but i got through itPackages are difficult to setup. For example, I use `lsp-mode` when I edit Go. Configuring `lsp-mode` to use `go-pls` was a nightmare. Emacs ignores shell init scripts so PATH is not right, the version of `go-pls` and `lsp-mode` must be kept in-sync, etc. This is really painful. I think that extensions need to maintain local installations of whatever dependencies they need, so that it's as simple as `M-x package-install `.* Learning how to make it work with CUA key bindings -- I didn't know that they existed so I started with C-w, M-w, C-y, I couldn't believe my luck when I found CUA in Emacs.keybindings and the sheer overwhelming options and possibilitiesMy fingers needed time to get in the habit of typing "emacs" instead of "vi" so for a while I had "alias vi emacs" in my .cshrc.learning keystrokes on windows vs linux vs macos. Even today the "GNU Emacs Reference Card" does not mention hitting escape before a key to get M- .Startup speed, not understanding how emacs internals worked, confused about how use-package/straight/quelpa worked, learning elisp in generalLisp is not a mainstream language and may be hard to graspLisp syntax (I was only coding C/C++/Perl before that)Fragmented documentation, very unusual keybindings for me, default config was very unfriendly for me, prelude helped me a lotEmacs is weird. I eventually got used to it, but it seemed a bit "old fashioned"I think that lisp and adding packages was the hardest thing to get around.The terminology (buffers, windows, frames) and keybindings were pretty foreign to me at first.Elisp when modifying and customisingLisp, but it's fun.So many things to learn and I don't know where to start. Probably we should provide a good roadmap for beginners.Figuring out how to setup an IDE-like environment, and more comfortable autocompletion.The tutorials. The basic one covers a little bit about emacs but it was really hard to find a tutorial without needing to install any external packageThe stock bindings I didn't understand very well after using vim for two years before attempting emacsThe behavior around fonts is particularly frustrating and getting everything to work well when attempting to use a bitmap font can be very difficult.All those weird keyboard shortcutsWhenever something does not work as expected or suddenly breaks it is hard to figure out what happened and why initially.- Discovering the packages that I need. Took time and was a fun journey, but it's not like it was obvious which to use. Nowadays this is facilitated by distributions like Doom Emacs. - Getting C++ completion to work for our project. Glad we have LSP now.Windows support a long time ago, not the greatest default configurationsIt is (still) difficult to find the good/best current practices.help was, at least then, very fractured, and it was kind of hard to find information in a way that's more beginner-friendly than the manual.Documentation is rough, and vocabulary is too confusing at first.The idea of programming your configuration file, because that's what init.el comes down too.Getting my head around the keybinds was a challenge, but which-key really helped. There should also be more focus in the tutorial on using the help system - once I was proficient with that, everything became much clearerMaking a config that works portably between environments.Myriad of choicesLearning the emacs way to do things. The client/server setup was required to make it snappy.Yes! For a very long time, I put off learning elisp, which was a mistake. I also struggled through learning how to use new workflows, manage packages, etc. I can only wish the book Mastering Emacs existed when I started using it.When starting you have to copy/paste configurations from others, and sometimes that could lead to problems and overwhealming.The key shortcuts were very different from the standard across the universe, it was very difficult for me to adapt. I learned to change them whenever I thought it necessary. The worst part was and still is the keys that use CTRL.프로그램 다루기it took quite some time to grok the concept of running a single emacs instance coming from vim, I assumed that running and stopping, and running multiple instances in parallel is the way to go but only later realized, that it makes flows much smoother, if you autostart emacs just once, and have this single one instance running, until the pc powers down again also configuration without something like use-package is pretty cumbersomeUnusual keybindings for default actions like copy and paste Workings of the kill ring and selection using marksProbably just the keybindsPackage configuration was difficult in Lisp.I would have probably given up entirely coming from Vim without Spacemacs, the streamlined and easy-to-use configuration made all the difference. Because this flattened the learning curve at first, the ramp up when needing to create my own layers or write Elisp was steeper than it otherwise would have been. I tried Doom Emacs recently and came back to Spacemacs after a month, it was too much like starting out with a vanilla setup (not for me).Too many overlapping/competing packagescryptic error messages not enough out of the box features- The fact that key bindings differ from most applications eg for kill/tank or navigating around - similar as above but for differing terminology regarding eg windows, pointers etc - Elisp was a significant downgrade in terms of baked-in abstraction power for me, coming from Common Lisp at the time. That's a relatively minor inconvenience though, since ultimately any lisp can be molded to one's preferences. - One nasty one at the time was that there was only dynamic scope in Elisp. Since then lexical scoping has been introduced, mostly fixing the issue.Installing Doom eMacs, undestanding shortcuts, not knowing anything about org modeYes, gave it up twice before becoming a daily user. This took about 2 years. The shift in paradigm was steep.I think the difficulties of learning everything is about the same; but Emacs, as a text editor, is kinda different than what people would expect, which makes it harder.Physical pain from the ctrl keyDiscoverability of functionality, elisp vs other lisp dialects differences, performance issues with long lines and io with external programs, learning key bindings.Coming from vim, none really.awkward UX compared to other editors, steep learning curveDIRED continues to be unintuitive and even underpowered. ETAGS usability seemed low.The daemon/client are hard to use correctly combined with desktop saves. TRAMP sometimes doesn't recognize a remote shell.the "C" and "M" key prefixes were awkward ways of phrasing "control" and "alt/option" and it took me a while to get used to that; also to get used to the command dialog in the bottom row of the screenThe default keybindings are a bit hardI remember struggling to set my own custom keybindings a few times. Setting up HTTPS/TLS for `M-x package-list` etc. was harder than it ought to be. Certain modes overlap in strange ways which the guides do warn you about, but even so, having to look through the packages and their mode bindings/behaviours was a bit unintuitive.I was confused by the process of customisation, I found it rather unintuitive and structuring my .emacs was a challenge in the beginning.Mostly reading and understanding what gets output to error buffer. Sometimes hard to accept that buffers a bit different to the usual windowed model I've grown up with.keybindings were weird (used evil for a bit), and troubleshooting is hard.Just in general understanding what was going on under the surfaceThe vanilla settings are pretty roughIt's GUI didn't feel modernIncompatibilities with VAX/VMS; different culture; it was a long time agoAs a prior vim user I got started with Spacemacs when that became popular ~7-8 years ago. It hid enough of the internals to allow me to be productive right away. When I first got past basic usage of Emacs and into configuring it via writing some of my own code, it took me a long time to get comfortable with it. Emacs Lisp as a language shows its age compared to newer lisps (e.g. Clojure, Fennel, Carp), and a lot of core functionality relies on buffers for state, which imho makes it easy to introduce subtle bugs. Newer libraries and packages tend to be more functional in style and reduce that risk.Learning how to read the manual and getting used to Info.Lisp is weird and the package management system is also kind of hard to grasp.Remembering the key bindings, then using them. The solution for me was evil mode.The default bindings are frankly terrible, and I have had to re-master them several times.Many. Keybinding, configuration, package use. Felt completely lost.Life is better after I learned Elisp 8 years ago.navigating texinfo helpI was struggling to find/implement features present in VSCode, but not in emacs: multiline editing, line moving, file browser and official editor support. I am still using VSCode for work, because I couldn't figure out how to use emacs for webdevProblems with gpg encryption (epa pinentry stuft)it was 26 years ago, so, no, I cannot recallweird keybindings, steep learning curve.Outdated terminology, usability issues introduced by buggy config (spacemacs at the time)Autoselecting major mode from file extension, undo grouping, discovering keybindings, activating a feature and being unsure what keyvibdubg I just typed, internal hooks, missing community in my localityEliseIt is a long time ago. The tutorial that came with Emacs and an .emacs file with explanations (there was not a lot of such things then) were for me very helpful and enough for the start. Sometimes was difficult to find solutions for particular problems. This is mostly the case, when other applications are needed. For example, installing and setting Email (mu4e). I wish there were more information, easier to find, especially for other systems than Linux - but hey, at the end, I always could gather the information, and solutions that work and work and work for many years.The keyboards shortcuts are not very intuitive, so it took a while. Lisp was also difficult for a 1st year computer science student.The default keybindings are absolute dogshit, super hard to remember. So glad I found Spacemacs. Names for functions and variables are dogshit so it was and is still very hard to figure out what does what without pouring through documentation or being really good at googling.I am not a programmer and use Emacs for academic writing in the humanities/social sciencessearching for answers in the internet instead of reading manualsNot much really confused me, after getting over the hump of the keybindings. Most of them are what I use anyway. The default colours did kind of look bad though. It should be noted that my first approach to Emacs was through a Lisp-in-a-box and so I learnt Emacs as a prerequisite to learning Lisp.Keybinds Finding packages "everyone" usesLearning the package system and building a reproducible Emacs setupBad defaults. Emacs is a tool to build your own text editing environment, but the default environment it gives you with no customization sucks. I understand that defaults are hard to change without breaking people who have been using emacs for decades but as a beginner you spend so much time copying code for sane defaults from other users you don't get to discover elisp yourself.Hard to remember keybindings.Chording is probably most difficult to learn, but worth the effortError messages when things go wrong aren't always helpful.Strange keyboard shortcuts, settings, different buffers and hard-to-follow instructions.The high use of modifier key chords forced me to permanently rebind caps lock to control.I hated the graphical interfaces and had a hard time understanding "faces".Lisp - nothing like any other language I've usedthe key bindings in spacemacs are different than a lot of the emacs docs out thereComing from vim, configuration was a bit tough for vanilla, so I first chose Spacemacs to get a pre-configured system (now Doom Emacs because I like the philosophy better). When your default keybindings are vim (i.e. evil-mode), it is hard for a beginner to use some packages because there is no built-in evil support for them. Even some packages I still use have some glitches because they are intended for the "default" bindings and it's not easy to fix those, especially for a beginner.Years back you had to configure everything ! There were editors around, that could be used more "out of the box". Key bindings were strange. Now I love them ...Understanding value of documentationnavigate as easily (because I was more proficient in) neovimDiscoverability, the discouraging fact that vanilla emacs looks like ABSOLUTE DOGSHITNot really. The keybindings were new, but that's just normal.Keybindings, how to navigate and documentationmissing single page documentationasync or multi-processingkey bindings, but i've grown to like themThe keybindings were hard to learn and discoverTimezone handling;Basic default key bindings are far to be the current ubiquitous key bindings (ei: C&P)Emacs Lisp, but got over that hurdle pretty quickly. Another difficulty was find the right package to do something as Emacs often has multiple options.Emacs requires a lot of on-ramp (and this is coming from a vim user). As an editor it lets me edit code pretty quickly but when it comes to anything else (org-mode, git, etc) there's a steep learning curve.It was all bad until I did the elisp tutorial. Then it was "all easy" from there.confused fingers from other editors, environments the depths of the key-command trees / modes and special buffersIt is hard to configure for someone who doesn't want to have to do much with elisp. Cursor/mark navigation and editing buffers is awful compared to 4coder.Lisp was very foreign to me at the time. Had I not been at university, I don't know that I would have had the time to invest to discover the benefits emacs have given me.it is _not_ accessible at all if you dont have anyone to show you around- unfamiliar Emacs keybindings - lack of mnemonics for `C-x 2`, `C-x 3`, `C-x 1` - stateful `C-l` - lack of ELisp understanding for initial config - `eval-after-load` - which feature to wait for? - lack of understanding where to find documentation - info - `;;; Commentary:` section in packages - README - docstrings - comments - just read the code, lolLearning the different key bindings was a little bit complicated after years of Ctrl+c, ...The flexibility is one of its main issues for the new starters. There're different ways of achieving whatever is desired from Internet, but it's hard to have a good out-of-box experience for a particular use with only minimal setup. All starter kits try to make things easier in all aspects but I believe some times putting boundaries would help.Emacs sometimes hanging when performing a macro many (hundreds, thousands) times in a rowIt's very hard to discover useful functionality out of the box.Consuming all the terminology and names in the ecosystem.hmm yes, i've struggled a lot to understand how to config emacs using elispI still find it difficult to gain understanding on what the current mode is capable of doing. I'm not sure what could be done to improve that.Not even knowing the Emacs terminology to search for documentation on what I wanted to do. Not nearly as many packages / out of the box configuration available at the time I started using Emacs.Different naming conventions for concepts (windows vs. frames, etc.pp.). How to figure out where to look for information / discoverability.Elisp isn't the most intuitive language. Also had some trouble in figuring out how to use packages in combination with Doom Emacs.I remember that when I first got started I was a bit confused about writing a config in org-mode and including it in my init.el. But now, since I understand it, it's great.MacOs Desktop Integration of Daemon/Client; Performance OptimizationIt is probably more Doom emacs specific, but I kind of like walkthrough tutorials that helix provides. Emacs would have been hard without vim background. Also Elisp is miles better than vim script, but it is dated. Helix does that in toml, which is neat, but any modern language will do?Well, back then, the difference between GNU Emacs on X vs. XEmacs.I was somewhat confused by the keybindings until I read the manual, which was very helpful.1. I made a serious attempt at using the default Emacs keybindings instead of Vim keybindings, following along with the book "Mastering Emacs". I think the keybindings make a lot of sense after a month or so of getting used to, and would love to use them to avoid the complexity of Evil. But in practice, even after mapping CapsLock -> Ctrl and Cmd -> Meta, I still developed wrist pains in my left hand after a couple of months of serious use. I tried various ergonomic tricks, like e.g. enabling sticky keys, but could never really get used to that. Probably an ergonomic keyboard might help, but I often travel and have to work on a laptop, so this is not a complete solution of the problem for me. My solution at the time was to go back to Vim, but I eventually came back to Emacs via Evil-based distributions. 2. Previously, I have experienced that Emacs could be extremely slow when using the packages that are required for my work. This slowness even on a high-end MacBook eventually caused me to abandon Emacs until I read about native-comp becoming available, then I came back to give it another shot. 3. When using Spacemacs previously, I had a lot of issues with instability. Packages would just randomly break or become mutually incompatible after updates, which was even worse since packages auto-updated when Spacemacs restarted. Eventually, this unreliability caused me to abandon Emacs, since it often negatively impacted my bill-by-the-hour work. My impression is that new endeavours like MELPA-Stable has helped reduce this issue compared to a few years ago. 4. Honestly, the *very* first time I tried Emacs, I "judged the book by its cover". Things like the toolbar icons looked horrible, the GUI didn't look at all like other GNOME apps (I mainly used Linux at the time), the modeline had a Motif-like dated look, and the default theme was quite bad. I think a more "sexy" default aesthetic would go a long way to get new users to give it a serious consideration.I am not programmer, I do not know anything about coding, I had to understand how this program works, what its philosophy is and how it has been built — one could say erected — for decades.very few; perhaps fixing the key mapping to make control key feasible.The tutorial is great and so is the documentation, however jumping from customize to writing elisp is a bit painful. Moreover most emacs internals, while documented, have poor discoverability. You literally have to know things are there or you won't notice how they might affect emacs. Also performance tweaks are poorly documented and/or have far too conservative defaults for modern (~10 years) computers.Was new to Lisp.Moving around (cursor keys were supported on the VT52 in those days) Trying to control what was displayed on my screen (C-x 0, 1, 2, 3; C-x b)There are a lot of functions and variables to learn, and it takes time to know where to lookI could say I am about to learn emacs. I will start with the GNU elisp documentation. I glanced at it before and it looks like an excellent way to understand the editor.vanilla emacs keybindings were hard to learnEmacs' initial keybinds have a high learning curve, sometimes syntax highlighting isn't quite as extensive as I'd like, indentation behavior is sometimes unusualGetting a grasp of what's possible with Emacs. Finding settings you probably want to change.lisp isn't straigtforward to understand, I used to copy/paste snippets to achieve my goals(E)Lisp is a bit of a bummer, especially in the beginning. I like types, and I have a hard time understanding Lisp. Many times it is hard to know how to change "something". For example, what function to add or remove from which hook (e.g., LaTeX-mode-hook vs latex-mode-hook); when to set which variable (e.g., before or after loading a package), etc.Grokking ElispNo, it just took a lot of time and diligence.many, and i'm unhappy them because the barrier to entry was uncessarily high. i came to emacs as a non-programmer, and became a programmer because of emacs. particularly irritating off-putting was emacs's refusal to use normal names for things (syntax highlighting, windows/frames, cutting and pasting, faces, scrolling). i know that emacs has specific versions of some of these things that shouldn't be obscured, but my primary memory of learning emacs was not being able to achieve what i wanted, despite intense enthusiasm and manual reading, because what i wanted to change didn't go by the common name, and i did not know what name it went by in emacs. this is a really basic thing, but it's really crucial. there has been discussion about changing this on the email list, on the topic of 'modernisation', and i think the wrong decision was made. the people who already know emacs need not suffer from 'modernisation' at all, they have existing configurations + knowledge, while new people are losing out by the refusal. which means that emacs is losing out by the absence of possible new contributors. an obvious example: CUA by default need not put anyone out, as people who know emacs could disable it immediately, while it takes new users a long time to work out that it exists, what it replaces (i.e things they've never heard of: yanking, etc.), how to enable it, how to customize it. my experience of learning emacs was that this kind of obstacle appeared at every stage, which made the environment seem obdurate and arcane. this is sad to me because emacs is valuable precisely in that it is demotic and democratic, that anyone can come in and contribute new things, and the huge amount of people who have changed it by doing that. i say this as a hopeless lover of emacs lisp (it taught me programming as such), and i am also not yearning for reckless 'modernisation': i mainly love emacs because of its 1980s-like rich text interface. but it shouldn't stubbornly insist on its own nomenclature, and it should be the responsibility of the people who know the obscure nomenclature to make the bridges between it and the rest of the computing world. to me it is patent that this is holding it back in general.Yes, Emacs key chords were difficult to use (coming from a Vim world), and I still struggle with setting up lsp servers for languages such as Java. It took me a long time to realize that Emacs should be a long-running process, and not started per file as I usually did with Vim.new the the concept of using the keyboard to navigate documentsKeyboard driven workflow did get some taking used to. This also includes learning the countless common shortcuts.The learning curve was extreme.Didn't know where to start Elisp functions had cryptic namesKeybindings, configuration, error messages.Out of the box the completion systems didn't give me enough context. Once I had M-x live searching and showing the docstring everything went smoothly.Learning the keybindings was a steep curve for me.The concept of a buffer was a bit hard to grasp. I wasn't aware of the daemon and had long startup times.It is absolutely impenetrable. There is no way to ask it questions from a _task-oriented_ perspective. The different help systems are all geared toward someone with an emacs mindset (functions, key bindings) and not a noob (how do i do x, where is this setting). The menu system helps a bit, but the important menu items are drowned out with lots of rarely used stuff.Concepts and keybindings are weird. I had to make an effort to understand the philosophy of the editor to make sense of what buffers are, how am I supposed to use them in my own programs. There is no overarching philosophy when it comes to developing elisp programs, you are told that people just discover new functions and macros by reading other people code but there is no documentation advising for some standard way forward.Didnt understand that C-c means control+c and not shift+c + cdifferent starter kits and vanilla emacs, also the installation and configuration on windows10Keybindings. The documentation is still too technicalInstalling and maintaining eMacs is unpleasant. Small updates break things so I often don’t update for long stretches.Obscure keybindings and customization, when compared with less powerful but more alternatives such as Visual Studio or Wordnone that are specific to emacs itself. i started with spacemacs which has its own issuesElisp is difficult, even coming from a computer science background.The manual can be quite opaque sometimes and lacks examples in placesConfiguring emacs is like learning a new language. And it's even worse when we don't know anything about LISP languages. It's way too difficult before you can pretend using it efficiently.Learning keybindings, _but_ I found it more natural to use modifier keys than vim's setup. The meta-x + name-of-command (and tab completion!) is very useful!Vanilla Emacs. It's a very steep learning curve. I still don't know most of the vanilla keybinds. The Vim keybinds + leader keys is (in my personal opinion) superior. If the official Emacs project made more mention of starter kits like Spacemacs and Doom, it would've been very helpful in saving me time. It took me longer to put trust in those two, because I didn't realize how many people used them, and that it was a normal thing to do, and perfectly functional.I can't understand Elisp at begin, so when I want to custom my Emacs, or I want to modify other's config (like Doom or Spacemacs), I run into error. This is really depressing, and I abandoned Emacs serval times. Finally, I begin to learn Elisp, write my own config (and copy others), and really begin to use Emacs.It was useless to me until I was able to get Evil working and it took a good bit of effort to do that. Package management and init.el configuration all have steep learning curves. Spacemacs served as a good starter, but the configs were so different that the move to vanilla felt a bit like starting over.Documentation very fragmentedStill don't have fluency in elisp after 4 decades. Completely arbitrary naming can make it hard to find things.the complexity of emacs, customising keybinds, understanding where to go if you want to change / understand some part of emacsYes, plenty. It doesn't keep up with time, and it's not as user friendly as other editors.IIRC, the main difficulty was to change paradigm from «conventional» editors, as it does not come with a very specific workflow for a task, and require you to look at what package exists and what is their differences and how to assemble them for what seems to be the workflow you wish.Frequent hangs Having to learn lispI had to resort using vim bindings since the Emacs ones were pretty difficult. I like the Doom Emacs and Spacemacs way of binding most things via the spacebar. It makes things a lot more discoverable together with the defaults.all the key bindings and the behaviors of the key bindings, e.g. search and then backspace, e.g. undo / redo / undoKeybindings, no immediate visual representation of multiple buffers.Default keybindings, appearance, configuration (this was a long time ago)Mastering the key-bindings, and it took me a while to 'get' the concepts of Emacs (I had the wrong questions, expectations)Remembering keybindings, and answering the question “how do I do X?”. The manuals and help system are fantastic, but in my experience they’re only useful when you already know what you are looking for.I'm self-taught, so getting used to non-CUA keybindings was hard at first. I distinctly remember being perplexed when C-s opened up isearch instead of saving.Doing vanilla emacs I remember was difficult. It was weird when doing it in uni (didn't know "oh this is Emacs" just "what is this old interface we're programming in??"). Then when I came back to it at my first employer where I installed Spacemacs which was a bit better but sluggish I felt. Then at next employer I met a colleague who used Doom which is snappy and I still usetons, and I still have them - moving was one - had to disable the arrow keys to force me to learn it.Setting keybindings is more complicated than in other editors.Not that I recall now after 30 years. IIRC it was no harder than learning any other sufficiently-powerful tool – particularly as it didn’t all need to be learned at once. My learning is still ongoing, and in a way I’m still in the initial-learning phase, gradually acquiring new knowledge on-demand (albeit a lot less frequently than when I first started).For just about any way I would like to use Emacs, not only has someone probably thought of it before but there will also be a useful guide or package all set up for me.discoverability of useful editing tools/keybindingsThe keybindings. I use evil now but I didn't initially know about it and tried to use the default keybindings when I first started.Just getting used to emacs, but discovering features sometimes took a bit of time.Obscure KeybindingsLearning about new packages and extending my base configuration. Learning how to integrate features to help making easy to code.entirely new key bindingsI think keeping all of the keybindings straight was the hardest thing for me. The powerful keybindings meant I was constantly afraid I would hit the wrong one and mess things up beyond repair. I think knowing about which-key would have helped me then. Something that still annoys me is also how often my window layout gets messed up. winner-mode helps to some extent, but it really frustrated me when I was first learning that my windows didn't stay where I wanted them.That 'starter packages' are needed at all. - It adds a significant research burden on new users. The defaults should be good (enough): That is: - standard CUA keybinds, - a better packaging interface (like dooms 'module' system), - a better-organized top-bar menu and - a better theme. Another pretty significant problem was getting programming language support to work: - Much of the online guides are outdated (e.g. recommending ctags or other wildly outdated things). - Installation of language servers is a proper pain. They often aren't packaged and do not provide repositories; Ideally enabling/installing a languages mode in Emacs should just pull the latest binaries for emacs-only use. Alternatively at the very least proper instructions (INCLUDING a link to the language servers repo should be given). However, I'm looking forwards a better future, with eglot being mainlined.Lack of documentation in Brazilian Portuguese.Writing the configSetting up an init.el and establishing the infrastructure for configuration (a problem Doom solved)Lot of surface API Lot of datatypes with small nuanced differences Official docs cover a lot of reference documentation, but don't cover many tutorials or practical problem solvingAn impression of too much information, but at the same time a documentation sometimes lacking. For example, the bbdb info page is not providing useful information. On the other hand, as a beginner it can be difficult to know what is the correct modern way to setup emacs to develop in language X.Doesn’t follow any software conventions as far as key bindings or commands (eg find-file instead of open-file). It’s hard to discover functionality.Keybindings different from most applications, like M-w/C-y instead of Ctrl-C/Ctrl-VGetting sensible defaults, learning the emacs way of editingVideos and documentation online is plentiful to discover it. Elisp is really strange to suddenly discover this way but I'm starting to get used to it. The hardest part is to grasp its very large and more often than not strange syntax. Distributions like Doom still lack a comprehensive summary/cheatsheet to quickly glance at to learn the keybindings but I feel Doom has the keybindings that suite me the best so far. Integrating some powerful tools/packages (like I had recently with automatic LaTeX compiling) is sometimes non-trivial but I could always find the solutions in the documentation or online so far. Naming conventions are all over the place depending on the packages used. Being able to do one thing in so many ways, while being a big strength of Emacs, is also a weakness when one tries to discover all the capabilities. But I can see that disappear as my workflow starts to settle in. Discovering is fun tho, I still find myself surprised, from time to time, to still be awake at 4 am tweaking my config.Getting beyond the bare bones configuration to start using things like ido-mode and company-mode.I developed RSI on my pinky finger and had to remap CTRL to CAPSLOCKEmacs lisp tutorials were not good at the time.Understanding how to configure emacs took several weeks, understanding the major/minor mode dynamic, and learning some of the shortcuts.It's hard to find introduction resources if you are not familiar with lisp languages. "Introduction to programming with Emacs Lisp" needs to be updatedI started with a framework and while that is great for getting started, it harmed my ability to really understand the underlying platform or how to navigate emacs should I be in a situation where my framework didn't load.I joined a company and was given an emacs config that provided an amazing experience (compared to what was common at the time, mid 90s). When I left, I didn't bring that config with me and I was not able to rebuild that experience on my own for years.No real difficulties. I was fortunate to have helpful and patient colleagues who showed me the ropes. It also helped that I already knew other LISPs.Keybindings, how the help system worked, why some parts of emacs was slownone, I was young.Learning how to work with keyboard driven interface instead of using a mouse.Too many add-ons. little more, most commonly used built-ins.Shortcuts, messing with my configuration and not being able to find what's wrong.Not knowing Lisp.If my configs was to suddenly disappear I'll just use any other editor. The sane defaults are not that great which is understandable cause of gnu philosophy but I am just too busy to care about it.So much information, docs are kinda vastUnfamiliar hotkeys.Learning the keybindings and Emacs-specific terms: frame, windows, yank, etc.Remembering useful keychords, e.g. "M-m" to move the caret to the first non-whitespace character.I started with Spacemacs and I am working on creating my own config. Spacemacs made it easy to get into a key mapping that I was able to start editing with (EVIL mode). Opening vanilla Emacs the first time is a complete mystery on how to get things done. Learning elisp is a requirement and I am working on getting better with it to attain a workflow I'm comfortable with. Using a framework like Spacemacs makes it more difficult as the structure of configuration is different from vanilla and leaves you with documentation that doesn't match your system.No; I started with Emacs for Windows by Vincent Goulet and it was comfortable from the get go. I did get used to the emacs specific keybindings over time, but it was a natural, "supported" migration.Learning navigation and elisp.configuration was hell back then. keyboard mapping objectively/ergonomically sucks, but I developed some kind of Stockholm Syndrome.Default keybindings not being easy to learnI've tried to learn how to use Emacs twice or so before, but I could not make myself like the keybindings. Of course, the internet (mis)informed me that vim and Emacs are equally powerful editors, so I decided to use Vim because of the (for me) much nicer keybindings. I am mentioning this, because the keybinding were the main reason for me not to use Emacs (could be considered 'too difficult'). At some point I learned about Spacemacs, and that it (Emacs), provides pdf-tools. So I tried Emacs again (i.e. Spacemacs). I find that the `SPC` concept together with the `which-key` package are quite a (genius) improvement over the Vim experience. Then, finally, I 'discovered' that Emacs in its core is essentially a Lisp interpreter and includes a fully integrated elisp IDE, which makes Emacs just the much 'superior' editor. I think most difficulties I had when learning Emacs were related to using Spacemacs (configuring evil keybindings, doing Spacemacs layer/package management). I think the `Emacs` tutorial should focus more on using the lisp interpreter (while teaching the keybindings, and window management etc.). Anyway, as far as this is relevant here, I am trying to help out as much as I can, and I am working on an alternative introduction to Emacs tutorial/article (in org-mode including code-blocks).Use of specialized terminology in the documentation.The interface. The keychords. The docs.Unintuitive window and frame management and navigation. Vanilla Emacs is not usable for beginner users. Would be much happier user if I knew some of the config frameworks like Spacemacs or Doom back then.Emacs needs help being more discoverable with some of its functionality (for example, for the longest time I didn't know about Occur). There needs to be more of an intermediate-level tutorial that can go over things like completion frameworks, and even writing simple major/minor modes, and packages. That is, don't leave this to third-party authors and such (though such efforts are of course appreciated.) Using Org mode really started to take me across the Emacs learning curve. Writing Elisp helper utilities to do certain things in Org mode (e.g., working with Org links) was a natural thing to do, and slowly led to understanding other aspects of Elisp. I even began getting more comfortable reading the Elisp and Org manuals.Editing files with long lines, learning to navigate between files and windowsUnderstanding the breadth of the available functionality and then the amount of configuration to get a good experience.I was 18 years old in 1988/1989. I learned Emacs in parallel to Apple Mac/CUA conventions. So since my first use of any "modern" (i.e. post-Commodore-64) applications, I have been "native bilingual," muscle-memory-wise. Meanwhile I first encountered Emacs Lisp at precisely the same time I was taking a course that required writing code in Scheme. So what would (for me, undoubtedly) have been a monolithically insuperable conceptual obstacle, was, by luck, perfectly natural. In short, a wonderfully serendipitous story for me, utterly lacking in any relevance to new users in 2022. :-)i did not know any elispThere was no System Crafters, so getting started was hard (getting used to this kind of workflow, configuring it). Doom Emacs is the only reason I didn't leave Emacs early on.Couldn't find meta key on a VT100 keyboard (it was ^[)Remembering the keyboard shortcuts. Changing the default indentation and tab behaviorWas quite slow on mac osUnusual keybindings.Default shortcuts are very uncomfortable and I needed to remap many of them to be productive.No, not really. I started with cut and paste for simple blocks of configuration code, then developed my own configuration over several years.I wasn't a fan of the default key bindings, because they seemed very unorthodox and awkward to type. I also didn't know how to query emacs' various help functions, so it took a while to get to know it. Actually, I'm still getting to know it, but at least now I know how to "talk" to emacs and let it tell me what it's capable of.Remembering key bindings. Overwhelmed by the sheer amount of functionality built-in.Understand elisp and libraryI kind of didn't like dealing with commands that moved the cursor when doing the tutorial because I would lose my place. Also opening and closing separate windows. (Not talking about buffers but actual separate windows for different content.) Also getting a shell open and dealing with the edge issues with that.Basically that except for System Crafters Emacs from scratch, there is not really a lot of other guides that explain how to start making your own Emacs config from scratch. If it wasn't for those videos I'd have never left Doom Emacs.unaware of full potential Emacs; had to learn emacs lisp to really begin to fully grokDynamic Scopeerror messages can be cryptic, difficult to get started with. default configurations need to be better perhapsWeaning off vi/vim key bindings. Using someone else's frame work (Spacemacs, later Doom) when in hindsight I'd have been better off starting with vanilla Emacs.First the configuration stage, you have to understand a little bit of elisp just to define key bindings and to create auxiliary functionsConfusing, unique terminology and behavior (windows/frames, kill/yank, "kill ring"). Packages that describe what they do, but not why doing that is useful. Poor documentation of elisp language.Different keybindings, different approach to windows/buffers (got lost), need to copy-paste elisp to get necessary configuration donedo not rememberWhen searching for solutions, would often get outdated information that didn't work anymore.learn the basic commands to move aroundI started directly with Doom Emacs which is fairly user friendly. One of the difficulties that I had was finding how to customize specific things, finding the variables that would change a specific package (didn't know about customize-group)Unusually keybindingFirst figuring out how to configure emacs through use of dot files.The perception that it’s difficult to learn.Configuration is not for the faint of heart. It took me a long time to realize that starter kits and frameworks were the wrong choice. Once I committed to writing my own init.el with use-package life became much more predictable. Also, elpa/melpa are problematic. You never know when an update will kill your Emacs, so I often just don't upgrade packages out of fear.Keybindings, setting/config without great tutorialun-learning vi keybindings. I still miss `:g`one issue was: I didn't learn elisp, but only copy pasted from others, stuff unique to me, I could not achieve.; Second issue: I did not know the the help system. And did not know how to help myself. Googling issues often did not help solving problems; Third issue: completion frameworks where ad in late 1990s and early 200x.; Fourth issue: Emacs felt slow (in the late 1990 early 2000s) and had a bad startup time (until I optimized my config), so I did not fire it up for quick tasks.No. After 12 years of VIM and an extensive config, I was having 90% of it set up after one day. However, ever since then the config and the power kept growing(;Painful keybindings, difficult to remember keybindings, could activate default keybinding and not know what i had done or how to undo it.figuring out how to get vi-like editing functionalityThe key for me was maintaining my own init.el in git. Before that, my attempts to learn were thwarted by little annoyances. Once I started fixing those annoyances, then it became an editor that I liked using, and it snowballed from there.Initially key bindings but I've grown to like themLearning key bindings, navigating with CTRL-n, p, f, & b.Getting multibyte characters and input method switching to workDefaults suckIt’s a large face to see.Sure, I still mostly google my emacs related problems instead of using emacs help systemKeybindings while coming from vim. Also, it takes a while to understand the package ecosystem.Learning enough elisp to understand my configuration. Learning new commands and their keymappings.I can't remember anything.Understanding the GNU Emacs mindset (from a technical as a community point of view).Movement, configuration, slow and steady.keybindsIt was hard to learn the keybindings. After learning them, it was hard to not use them in other software. The kill ring was (and still is) unintuitive. It's still hard to get used to the fact that killing a word replaces my current clipboard with that word- I often felt that things that were very simple in vim (like replacing text inside delimiters (like quotes)) were very manual in Emacs - I still struggle with setting up Emacs as an effective C and C++ IDE.Lisp is hard, and also I don't like much the emacs default navigation keybindings- discovery; I would look for how to do something find it and at a later date I can never recall how I did that thing - lost focus on what I was working on because I had to figure out how to get something to work correctly (for example org export)Getting accustomed to keybindings, configuration.amount of functions are overwhelming, lack of module/namespace making it seem less organizedPoor default configThe learning curve is steep. Back when I started, Spacemacs and Doom weren't a thing so it took me a long time to customize my Emacs to look and behave the way I wanted it to.Configuring and understanding how things work.Nothing aside of it being unfamiliarNothing is overly difficult, there is just a lot of information to take inRemembering keybindsCan't sayIt is not very intuitive for a beginner. I tried and gave it up at least times, before eventually getting hooked. But at the same time, I would not want the strengths of Emacs to be compromised to make it easier for newbies.Understanding basic concepts like the kill ring. The ergonomics of moving around.Keybindings were the first hurdle (e.g., I pressed ctrl-Z to undo and the window disappeared). The community can be snobby and dismissive to newbies.Mainly the immense number of things it Emacs can do. Im still finding new things and learning every day.Configuring it to look modern was difficult. Getting code completion and other "ide" like features still mostly doesn't work as well as other editorsLearning curve, particularly learning elispYeah, elispKey combinations- The different keybindings from what I was used to: copy/paste, for example. - The concepts of buffers and windows. - I had no knowledge at all of elispGerman keyboard , keybindings designed for quertyUnderstanding the idiosyncraticities of elisp took some time. Understanding the difference between buffers, windows, and frames. Understanding how work is being performed on a buffer, and what save-excursion does.Lisp, weird keybidings and we hard to compile or debug c/c++ projects with.Before I started using Doom Emacs, I felt it was very hard to configure Emacs.The quick shortcuts.Verbosity of documentation was often quite inconsistent, some things would be documented in great detail and approachable language, while even within the same resource, some things would be documented in extremely terse language with heavy use and lack of explanation for jargon. This sometimes left me unsure why I wasn't able to understand certain concepts as easily as others they were placed right next to.New key-binds + command oriented work-flowsThe configuration was opaque and out of the box, it had barely any features. Starter kits changed that.Committing key combinations to memory can be difficultUnderstanding the way Emacs works required a change in paradigms. Once I freed myself from the preconceived notions of software usability, UX, something clicked.emacs keybindings are weird. I have vi and emacs bindings mostly memorized, but prefer evil modeLisp (let alone elisp) is beyond niche at this point... I have zero interest in the language and it's a chore every time I have to even think about using it.Keybindings, lisp.Trying to start using vanilla emacs in the terminal emulator just by reading the info manual did not work. Watching the system crafters youtube channel and using Doom emacs pre-configured was much better.Struggling with poor defaults. When I started, font-lock was not on by default. It's gotten better but there are a lot of things that are really easy to fix, but you have to know how.i have no understanding of the internal workings of emacs at all but I would love to. if someone would articulate that (along the lines of this *great* article https://ciechanow.ski/mechanical-watch/) I would gobble it up in no time. not understanding that limits me severely, I feel.Too far in the pastQuickly scrolling through files would be very sluggish. Sometimes the LSP client (via lsp-mode) would hang, and I'd just have to stare at my screen while waiting for Emacs to let me continue editing my code. One very specific issue I had at the beginning: CTRL + Backspace did not behave like most other text editors I had used. When using it at the beginning of a line with only whitespace before my cursor, I expected it to remove the whitespace up to the last non-whitespace character of the previous line. Instead, it also deleted the last word of the previous line. A bit annoying, but I ended up changing how that key combination behaves.Learning key bindings and working without the mouse. Installing and configuring packages.key combinationsConfiguring it to run a modern web dev setup with tsx, prettier support.I didn't know how to use it until I found emacswiki!Yes. I didn't learn emacs from internet sources at first. The turning point was when I found *info* (C-h i). I wish I had found it sooner.difficulties with elisp ; vanilla gui is really awfullUnfamiliar keyboard shortcutsDocumentation/introduction docs are lengthy and is bogged down with lots of key commands that are mentioned for completeness, but made me feel like I needed to memorize everything even if I didn't need it for a long time. A lot of material about emacs focuses on the what and how but not the why which made understanding the emacs take longer than it should have. Evil mode is nice, but a lot of packages don't play nicely with evil keybindings; however due to the keybinding precedents, evil's keybindings take priority over theirs which can get really annoying to deal with. In general, figuring out which keybindings being applied in what order can be a really hard effort. When I tried emacs prior to using doom, the amount of configuration needed for setting things up was just too great while in the process of still learning how things worked. Startup times in emacs can be awful. Thankfully doom has lazy loading of packages in place, but if I was using emacs without doom, I think it would drive me up a wall. It took me a long time to figure out how I wanted to organize my emacs configurations. Because there is so much configuration needed, it can be really difficult to figure out where you want your configuration code to go. Especially when starting out and you don't even know the world of possibilities awaiting you. I've not been able to find a good high level overview of emacs concepts (aka, ignoring keybindings and specifics) that may be unfamiliar to new users. Examples of topics I would have loved to have had better explained would have been: faces, buffers, frames vs windows, how emacs is basically an elisp-repl that works with other text too, how emacs' package system works under the hood, how emacs' loading process works, etc. I've wanted to use elisp more but there is very little in terms of documentation or tutorials surrounding it.Help (about functions, keybinds), Documentation, etc isn't very apparently to newbies. You need to know what you want help about in order to find enough help to be helpful.14 years ago there were fewer starter kits; finding and configuring tools for the languages I needed (at that time, Clojure) was a real challenger. That said, the basic distribution is pretty anemic, perhaps something that points people to collections of functionality (i.e. tools to support a particular language) may be helpful to those new to Emacs.Hitting backspace on early machines would send C-h and drop you into the help system rather than backspace the cursor. Was initially a major obstacle, but is better now.hard time wrapping my head around basic concepts of emacs like buffers, windows. bit difficult to figure out which completion framework would be good for a beginner.Understanding the difference between buffers, windows and files. Getting a version of emacs that plays well with MacOS outside of the terminal.As a Doom user, I found it difficult to find keybindings for modes while using Evil, which overrides keybinds that many packages use.Too much information to absorb, documentation is great but very long, requires a lot of time and dedication to get startMany howtos/tutorials out there use far too many packages for simple thingsDifferent terminology, learning elisp. Too much documentation and too few tutorialsConfigurating Emacs is quite daunting in the beginning and it is easy to make mistakes when copy-pasting code one barely understands. I did not encounter Lisp before and was not used to the syntax nor much of the terminology. While there is likely a function (or package) for many of the things one might want to do, actually finding it is not always easy; built-in help system is very useful but navigation has to be learned too. Efficient and power-use requires very regular use to keep keybindings, function names or package names in memory. It can feel like sitting at the helm of an air cruiser where any keypress can trigger something -- powerful but also overwhelming; still find myself using C-h l quite often.sure, alway learnig...No idea. It was ages ago!Complicated key bindingsTakes time and practise to get proficient with it.Key bindings took awhile to get used tothe help screen pops up, but is not like a man page, so I ignore it and have no time to learnKeybindings often were difficult to learn/memorize.To get things to "just work" I often had to copy and paste bits of config without really understanding why or how it was doing something. After rewrites to my config I now mostly understand why I have each line in there and what each line does. Some documentaion and packages are also very old, sql specifically comes to mind, and it wasn't clear how to go about implementing that functionality or if I even should implement it or write my own instead.Default keybinds were difficult for me.Switching from vi key bindingsBroken configurations (i.e. lsp not working properly)Package management was confusing until doom eMacs, package creation process is still confusing, package discoverability is low & required familiarity with community, package setup often (though not always) MUST be manually configured and lacks a “usually-sane-defaults” option, often ran/run into freezes which prevent closing relevant processes and/or switching to other tasks.I think the keybindings seemed weird, even in 1991. There was no community beyond the Usenet newsgroups, and no easy way to figure out if emacs could do something. C-h w and C-h k were great, though. Info was cool.Shortcuts were not clear. Even now I stumble on copy/paste (kill/yank). But using visualized kill/yank history helps a lot.the theme was olivegreen which id di find weirdComing from vi, the key bindings and editing mode were difficult, but at this point, I think the key bindings are fine and I dislike modal editing.Need to remember keybindings. The whick-key package is great.Chording and remembering them allTime to set-up.learning lispThe defaults are honestly pretty terrible. The jargon is also a little weird compared to standard programs. Once I learned the jargon and the 'concept' of emacs, I felt more comfortable. If not for my willingness to get good at emacs (realizing what it is capable of), I would have dropped it fairly quickly.A lot, learning all the ecosystem and philosophy behind itLearning new and different keybindings and movements, a different way of managing buffers. Not being proficient with Lisp. Not many concise and straightforward starter-level documentation around to look up.Understanding that the way it works is different from Vim'sSize of documentationDiscoverability of help was there but you had to know how to use itA very elitist community (20+ years ago). I had no experience with any LispSome of the keybindings are hard to memorizeIt's been too long since I've had to learn Emacs.The keybindings took a while to memorizeit is a pain at start. after copying some code from emacs gurus and extending it's usability for our work flow benifits us a lotIIRC the keybindings took me a little while to get used to.Mostly used Vim keybindings due past Vim usage for many years. Using some Emacs binding more, but slow to get used to. Most OSes seem to have old versions, slow to provide new versions, so had to search around alot for themThe sheer volume/size of Emacs. But that is also one of its biggest strengths.Yes, longer command combos are hard to remember so plugins that show options you could use are helpful.The keybindings is not inherited from the macOS default, the default behavior of the UX like open and close window is weird. The terms like buffer, window and frame are confusing.The keybindings in generallack of clear onboarding instructions, wrong assumption that app could only be run in the command lineIt took me a while to make the transition from using Spacemacs to my own customization (about 4 years).Overload -- there was a lot of information to take in, most not covered in the tutorial. Might be better if more packages and features had (isolated, self-contained) tutorials. Maybe would be useful to build a standardised system in emacs for this?Without a doubt: there are tons of packages that are widely used, but it's hard to tell them apart and know precisely what each package is doing. E.g. when I started, the word on the street was to use ivy + swiper + counsel. Although I roughly know what these each do now, I am ashamed to admit that I'm still not completely sure (especially about counsel!). It would be great to have a precise explanation of each Emacs subcomponent, e.g. "This is what the Emacs experience comprises: competing read, in-buffer completion, the minibuffer... Let's explain what each of these are, in turn." It would be very useful to see how the features behave by default (and what their scope is - e.g. in-buffer completion vs completing-read), and how they are modified by each individual package.Emacs conventions are different from the expected.It was quite overwhelming to learn 1) a new editor 2) a new language 3) a new eco-system 4) a host of completely new keybindsLisp was very scary initially.Getting started. Emacs offers very little in the way of guidance for newcomers without a specific use case in mind. There was no example pathway that highlights the strengths of Emacs in customization and extensibility. I was drawn to Emacs because of Org-mode, and most of my Emacs specific learning has come from trying to configure Org-mode to suit my personal use case. When I found that I wanted a way to sort agenda items that was not provided by default, I eventually found the internal code of preexisting agenda sorting comparators to use as a template and created my custom comparator function with the modifications that I desired. If I didn't have some prior coding experience as well as prior knowledge about how to navigate Emac's internal help menus, I can't really think of a realistic way I would have been able to take advantage of Emacs that is unique from someone's proprietary IDE (from a usability standpoint). Generalizing this away from a plugin specific example, the goal and benefit of learning Emacs over other tools is very implicit without much in the way of specific guidance about "how do I take advantage of Emac's customizability?" I would suggest something like: (1) what if you want to auto-save? (2) here's how you can enable the built-in feature by settings some variables (3) if that's insufficient for your needs consider building your own functions to fulfill that purpose (3a) why don't we look at the existing auto-save functions for ideas about sane ways to do this? (3b) here is how to use the internal help menu to find variables and functions by name (3c) let's copy the existing auto-save function and modify it slightly to experiment with customization (3d) testing the new function, iterate, troubleshooting (3e) etcIt can be difficult to understand Emacs' internals; I still haven't wrapped my head around them or around lispemacs tutorial was a bit boring and i dragged my feet when it came to learning the keybinds, but that's mostly a personal issuediscovering packages with functionality I was looking for (again, this was 20+ years ago, now it is quite nice), internalizing the terminologyThe learning curve was steep. No steeper than vi though.I spent several years using it as a glorified notepad with CUA enabled, and primarily using it for simple scripts and TeX editing. It took a long while before I started using the built-in keybindings, primarily because it did not seem worth it at first since they were so different. Switching to using linux more helped a great deal, since the keybindings are more universal there.Configuration (I didn't use Doom back then), learning Emacs keybindings, then learning Vim keybindings.Documentation is very comprehensive but sometimes you just want to get it working rather than read pages of in depth documentation.Key bindings, and the idea of buffers and files.Initially hard to customize (Elisp), not very beginner friendlyI initially tried Emacs for around 3 months but got burned out by learning everything all at once. The next time I tried it I used it for work as simply as possible and added features to my workflow one at a time.No difficulties at all. The manuals are great and always surprised when people don't read them.The tab versus space dilemma. Even 20 years later, it is sometimes difficult to set my Emacs configuration to correctly handle the spaces in a project I haven't started.can't remember problems. It's so long ago.Making it behave like vimBuffer and session management or something like workspaces were confusing or hard to achieve.- Keybindings. I started with CUA-mode (but now use vanilla). - Creating a new file.installing/removing packages to try them out (eg. if i wanted to decide between ivy and vertico do i use require, use-package, or m-x list-packages? safe to mix and match methods? wiki has an "installing packages" but not one for uninstalling) organizing dot file(s)Elisp code was opaque to me and I had to learn lisp to really understand what was going on. Also, initially I was switching to emacs from vim and so I thought it was necessary to use spacemacs for vim keybindings. Evil mode alone would’ve simplified things, and of course vanilla emacs keybindings are the easiest to work with in emacs. The difficulty with learning is the expectation that you can be an ultra productive user right off the bat. Like anything, expertise takes practice.WTF!?! WHERE TO START??Bindings, elisp, poor documentation and user introductionThe learning-curve is steepKeyboard configuration was difficult to get used to, but this was the 90's and it wasn't that hard to become accustomed.Started with Doom emacs but followed customization advice meant for pure emacs. Which meant I started configuring packages in a way that conflicted with Doom emacs. Did not really understand how to inspect configurations that were already set in the beginning. Exploration is even now a big painpoint. Figuring out what package can be tweaked in what way is not straightforward to me. Finding all variables a package provides for customizability is not straightforward.* I struggle to adapt to Emacs' keyboard shortcuts, since I use Windows-based editor for a long time. * It is difficult to setup right configuration since any suggestions on internet is always outdated.default keybids discoveryIt was hard to find tutorials in elisp.Discovering useful functions and packages. Debugging errors.The main difficulty was becoming proficient at using the default keybindings. Before starting to use the default keybindings (initially I used vim/evil keybindings) I had to think about how to remap the keys of the keyboard so that I could type as ergonomically and proficiently as possible.Could not remember how to split/close panes. Most of the shortcuts/functions were hard to discover.Since I originally used Doom, and although that was an easy to use configuration, I had no idea what was going on under the hood. Building my own configuration helped me learn a lot quicker.The are and have always been features that /look/ like I'd use them, but I've not found a way to make them work. For instance, the client-server mode seems like a good idea, but it has quirks that make it infeasible for my work.Installation and build process, steep initial learning curveIt’s massiveCEDETFirst time I opened Emacs, I immediately closed it, because he was very ugly to me, and I had no idea how to use it, so I started searching about it online, and I discovered the Emacs distributions like spacemacs, doom-emacsA lot of time to learn, too much effort to configure for work with programming projects (auto-completion and other usual things that provided out-of-the-box by many other editors).Configuring a productive development environment, now a much easier problem with the introduction of starter kits.I don't remember any major difficulties - the Emacs tutorial was enough to get me startedThe tutorial/introduction isn't beginner friendly. I spent a long time outside of the emacs documentation before getting comfortable.keychordsIt was very hard to make Emacs usable from default settings. It took me the better part of a day just to try and enable dark mode and that was just one of the things I wanted to do. I ended up installing Doom Emacs and it showed off the capabilities of Emacs right from the start. It blew me away and I stuck with Emacs even that it had a steep learning curve. To understand elisp and other Emacs specifics I remember it took quite long. Often times I end up writing something that has no errors but does not work as intended e.g. setting a key-binding, using hooks wrong or trying to set up a package. It's also very hard to debug, I was used step debuggers that show values of variables and so forth. In Emacs I just get a stack trace that is hard to decode, specially since it's hard to check the context and values that was involved.It is an ugly and scaring program. There is no attractiveness for a beginner... Also, at least company-mode should be enabled by defaultBuilding it by hand for different flavors of unixLearning the native keybindings was very difficult. Doom Emacs made it easier but I stil found myself just calling the elisp function via M-x most of the time. This is probably due to me not using an American keyboard layout. Understanding how frames work was also difficult. I ended up opening the same buffer in different frames multiple times.It's hard to find the thing I want to get configured, it's really overwhelming.Windows support is lacking. The vanilla experience is underwhelming compared to something like VSCode or the JetBrains IDEs. Hard to find documentation for Doom specific stuff.Manual is good once you have some experience how everything works; clear and concise. But as a new user who's tempted to wet his feet to explore the flexibility of Emacs there's no simple guide to get started. I would have wanted to kick the tires a bit and see how my workflow could be changed using with one tool (ie. shell, ssh, git, ide). Sure it's all changed now with Eshell, tramp, magit, treesitter, fly-check et. al but it took quite an effort get there. So I guess I was missing kind of opinionated tutorials how to set up Emacs for work.Nope. It was the first editor I "learned" (even among modern editors/IDEs).Edit configuration, manage windows/buffers, learning key bindingsA very little information aggregated as cheat sheets. Suck stuff really helps at the very first steps.Getting used to looking stuff up with C-hkeyboard shortcuts felt awkward and highly unintuitive. Now using doom emacs, which really brought me back to it after using vim for a bit, and the defaults feel much more sane. Shortcuts to find documentation on various things, and navigating it inside emacs was also a huge struggle. I'm still intimidated by a lot of elisp to hack too much on things.Some parts of the terminology are different from what I was used to in more "mainstream" editors. The "base" Emacs (aka right after a fresh install, and without any config) seemed a bit "harsh", "barebones", and I had no idea where to go from that point onwards.Not really, but I had been using an editor that is somewhat of an emacs alike.Initial learning experience was very bad because of bad standards... immediatly switched configuration to Doom Emacs.Remembering the common keybindings. The tutorial is helpful, but the navigation keys could be introduced later. Really it would have been easier to introduce just: C-x C-f (open file) C-x C-s (save), C-x b (switch buffer), C-w (cut), M-w (copy), and C-y (paste). The rest of the common tasks can be done with the standard way that other editors do it (i.e arrow keys/pgup/pgdown, etc). And after the user masters these first commands then they can try to expand their knowledge.Yeah, it takes a few weeks to get used to the keychords.Strange terminology, poor defaultsMostly around hurdles in understanding something very strange and alien. It's like the old joke about how someone tried Vim for the first time but couldn't figure out how to "quit". I had the same problem in Emacs. Emacs upon start-up presents very little about itself other than a dated looking UI and expects the user to try and figure it out or find the documentation. Even the message says (something to the effect of): "To learn more about GNU Emacs, press C-h C-a" it makes the _expectation_ that you know what that means. If Emacs were built today, I'm sure there would be a walkthrough and a new user UI that highlighted important and salient points and there would be a giant Help button stuck to the UI. I'm not saying that Emacs should go this way, but what I'm saying is that times have very much changed.I really start to picking it up after I've learned how to find help on packages, shortcuts, functions and variables.Discoverability, finding packages already installed that I did not already know the name of was tricky for a while without a sense for naming conventionsI started my vanilla config and I followed David Wilson’s videos loosely. Im on Debian 11 with Emacs 27.1 and since my apt packages are older eMacs had a version of org mode built-in but I wanted to upgrade so I think I used the gui package manager to install the most recent stable release from Melpa and it broke everything. I don’t recall how I fixed it. I’m leaning toward the complete removal of eMacs and reinstall of it. Eventually I got org going and wanted to try to make a literate config I was hearing so much about. When I did it, despite following multiple examples exactly, my config wouldn’t tangle. It was for i3 wm. I had to reach out and was told to use conf as the language and that It wouldn’t or shouldn’t tangle a plain text file without that. I now use Doom and have learned vim but I struggled hard to craft my even very basic config and my system configs at the same time. I was stuck between a rock and a hard place constantly breaking either my window manager, eMacs, app launcher, or other utilities pretty much daily for literally two months. Also I took the challenge of implementing in vanilla eMacs the fix that doom has applied toward org modes odd windowing tendencies. I believe i stopped it from deleting other windows and eventually used the display buffer alist and some investigative skill to control the pop up org mode windows. Now I’m on the fence about doom vs vanilla. There’s a lot of excess bindings and settings in doom that feel more of a universal cater to all situation. Im looking for more control again…The keybindings! Worth the investment though, specially for bash command line editing.Certainly, default keybindings were tricky, and I flirted with CUA mode. But partly because macOS itself has similar keybindings for text navigation, I perseveredI had difficulty trying to integrate features from Scimax (I liked org-ref and all the other features of Scimax) with the package system of Spacemacs. I eventually rolled my own configuration that integrated parts of each. I eventually moved to Doom since it allowed a level of flexibility without having to worry as much about potential conflicts (and included lots of sensible defaults).I started with Emacs when my only access to the nets was in the university (BITNET era) or by 300Bd modem to "silly" BBSes. That wasn't helpful to get my questions answered where I had them frequently: Sitting in front of Emacs at home.- vanilla emacs had (?) an ugly default theme and a non-intuitive and ugly mode-line - using emacs with all the strange, non-intuitive keybindings to memorize was demotivating, coming from nedit and vim. thankfully there was evil mode around. - setting up emacs to your needs can be very overwhelming. the Systemcrafters "emacs from scratch" series helped a lot with this.key binding is quit different from other appDon't recall - emacs was the first serious text editor I learnt to use, and it was a long time ago.Difficult keybindings.understanding what a "buffer" isUsing Spacemacs and Doom hinder my understanding and bug-solving abilities.The key bindings of course took some getting used to, but I remember the learning curve being easier than vim. Might be because I took up using vim from nano, though, which is a bigger leap.- default keybinding felt very unintuitive - Elisp errors are pretty cryptic (still haven't figured out how to use the debugger) - debugging freezes or crashesRelearn new keybindingsThe default key bindings are so unintuitive and unergonomic I almost quit immediately. I forced myself through it to be able to have a good Lisp editor, and stayed with them for a few years. Then I went with evil and fell in love with Emacs anew. Then now I switched to meow just a few weeks ago. It's what I wanted all along.Keyboard shortcuts are challenging: designed for a different keyboard to one that everyone uses. Remembering keyboard shortcuts was hard. Still is for new things.Working with the clipboard, problems with hotkeys when I used a non-latin input languages.Many but always found my way.The commands aren't intuitive if you come from a windows background.nothing major comes to mind, probably can`t rememberConfiguring Emacs to use custom fonts is and was way too hard.Knowing where to start. Defaults aren't really well suited to opening a file and cracking on compared to "Modern" editors.Things that stay in Emacs historically (for example kill, yank instead of CUA)Understanding the ecosystem and packages used. When reading other people's init, I did not know the difference between use-package, leaf, setup etc, and the origin/reason of the packages.Basics of navigation, window management, saving workspaces, and executing/navigating code. Also, debugging configuration.setting up config file, how custom works, what are packages and the different ways of accomplishing similar thingsi had to run at it two or three times before the possibilities became apparent, and possibly outweighed the frustration of someone used to whatever Ms windows editor i used previously. emacs is pretty weird.finding capabilities, fixing mysterious behaviorFiguring out the package ecosystem, which packages I actually needed and how to properly configure them. The fact that several packages solved the same problems made it worse as I lacked the knowledge and experience to make a choice. Discovering Doom Emacs solved most problems while allowing me to learn enough over time in order to eventually drop it in favor of my own custom configuration.Too much options, too many keyboard commands in different modes.No because my first editor was Emacs so I had no frame of reference from which to judge it easy or hard.Very underwhelming default experience. After a few trials with the default keybinds, I realized I really wanted to remap C-c and C-x, but it was quite hard with almost no knowledge about emacs/elips at the time. I almost give up on Emacs because of it.1. The non-standard keybindings, but once I understood how they all fit together thanks to the tutorial and the Mastering Emacs book I started to appreciate them being different. 2. Understanding the help system and how to actually search for things in the info manuals. Once you get used to actually reading manuals everything falls into place. But it does take a while to realise how much of a treasure trove the Emacs documentation is.Weird language lispemacs pinky fingerI found the manual to be at the same time (a) verbose, (b) not very useful to go beyond the basics, and (c) overall unfriendly to folks not used to lisp (or hardcore programmers in general). This locked me out of making Emacs my own personalised editor until I got better at searching for packages (5 years later, once GitHub became a thing) and reading them. I also remember finding the lack of "batteries included" to be a painful point, especially as at the time I was also learning to program and finding other friends / students / people using IDEs and getting things like code completion instantaneously working. This got somewhat addressed when the first few distributions came out (Prelude, first, but Spacemacs and Doom perfected the idea), but would definitely still be a pain point if they didn't exist to deal with the baggage left in Emacs in its default settings that it carries from being an editor built for the 80s.Hard to learn key bindings.setup was hardIt was difficult to find relevant help quickly. Now, I just search on the web.Lack of "overview" documents that describe Emacs architecture/key concepts. Most documents I saw 7 years ago were "example of Elisp configuration".getting used to the keybindings. Different concepts of windows and frames, didn't know elispPackage management and debugging customized configuration is difficultkeybindings, not so discoverable... how do you know what c-u does/changes? how do you discover how to copy the full path of a file in dired? c-h m does not help... apropos does not help... the self-documenting system, in case of emacs is a myth!Cryptic error messagesKeybinds, UI/UXCargo cult programming: lots of code (.emacs) snippets taken from here or there, was not easy to find back then a good source of good examples. As a beginner it's impossible to figure out the good from the bad code snippets. Meanwhile it's better: layers like DoomEmacs minimize a lot the need for user configuration. This is a good thing.I knew only some base keybindings and it was hard to understand what I can do (how to find other etc.). In addition, I was confused that there are several different setups like spacemacs, doom etc.When you copy and paste some configuration and an error occurs that is incredibly unclear and doesn't appear on googleGetting up and running with LSPWhen initially learning, I was on macOS, and figuring out which version of Emacs to install and whether or not to use a framework like Doom was difficult. There were something like 4 or 5 different repositories I could have downloaded "Emacs" from, and it was not obvious what the differences between them were (and they were different, some including their own downstream patches). I also had to decide whether to go vanilla, Prelude, Spacemacs, Doom, or other. I was used to making zero decisions when installing a text editor, so having to make several before even running the program might have stopped me from going through with it if I didn't have a colleague & friend who knew what they were doing and could guide me. The learning curves of the vanilla Emacs keybindings as well as the paradigm of customization-via-lisp-programming were also steep for me at first, but nothing that practice didn't get me through shortly!Lisp is not easy to understand. Some snippet are not working anymore.Steep learning curve but I went in expecting that. So no difficulties.My initial learning has been 25 years ago, still I sometimes feel as if I am still a beginner as there is so much useful stuff around, that you do not come across automatically.Elisp configuration is hardKeybindings were difficult and different to what I was accustomed to in the beginning but with persistence I overcame the difficulties. The expansiveness (huge number of packages and configurable parameters) can be intimidating.How to help myseld and how to use Info-modeInstall and configure are trickyuncommon usage of term (window, frame, point ...): Emacs has created a own world ... much like SAP etc.30 years ago lol I was pointed to the tutorial and C-h i texinfo and asked to read that first. which was great advice. As a CS student, concepts clicked into place quickly and easily.configuration of system defaultsLearning the best sets of keybindings to accomplish the workflows I was aiming for whilst trying to figure out better workflowsA very steep learning curveLack of conventions, like how things should be done. There are many ways to solve the same things but most of them aren't really working and I had hard time finding good sources for that.Learning all the basic keyboard commands, editing text, opening and saving files—debug-initThe biggest difficulty I think is figuring out terminology (yank, frame, etc).I still feel like I'm initially learning emacs. It's hard for me to break out of (probably inefficient but overlearned) ways of doing things to more efficient approaches. Most emacs learning material tends to be tutorial in nature (way too basic or disconnected from "real world use") or manual pages. I would love to see expert users, who have their own custom set up, first show how they work for an extended period of time and then break down their idiosyncratic ways of working (their .emacs, their packages, etc.).Key bindings were hard, but worth the effort. Changing from a file/window/tab kind of mental model to emacs file/buffer/window/frame model was a bit confusing at firstI initially disabled backup and autosave files because I couldn't figure out where they were coming from and once I figured that out, it was easier to disable than learn how to use themnot very advanced vs other text editorsRemembering all the key combinationsWhen i tried to configure Emacs for myself. It was not so easy. I am glad that i found Doom EmacsIt took a while to understand how important is to learn how things (that are very Emacs specific) works (buffers, undo, etc) and also how important is to have a good grasp of elisp.1. Do not know where to find the "right" configuration 2. Do not know which package can be used to solve certain problems.I generally struggled with the workflow. No cua bindings per default and my brain where so hardwired to them and CUA mode made learning all those unusual keybindings even harder to learn as there is another translation step sometimes. Mastering Emacs gave me the understanding of how Emacs ticks to _actually_ learn Emacs.The discoverability of the features was not very good. It was my fault though, I disabled all the menu barsConfiguring emacs is not easy, especially knowing where things belong. Lisp-side, I still struggle with all package-importing flavors: straight, require, etc.No, the community was great even in 2010sslowMaking changes to the Emacs initialization file. Apparently, the initialization file can be one of several options. It took me a while to figure out which file Emacs had used, so that I could make changes to that file.emacs's single threaded nature caused me to lock up emacs way to muchCouldn't get used to the default keybindings. Having to use elisp was a major difficulty, usually spending hours trying to get some simple setting to work. (It still is to some extent)needs to have more batteries included for sureGrief, it was 22 years ago. I did a big switch: CSH to Bash, Vi to Emacs, and QWERTY to Dvorak all at once. Everything was a struggle to re-learn.Differences compared to common conventional Windows applicationsweird pre-CUA keybindings, i had to hang up a reference card next to my deskI think the main difficulty in general is just spending enough time with Emacs and its manuals to discover and become aware of all of the features it offers, in order to build a good mental model of its domain. This is not completely trivial to do given the size of Emacs and the "chaotic effect" some low-quality tutorials/suggestions on the Internet can have on your mind. It took me a while in the beginning to stop googling mindlessly and take a structured approach of skimming and reading through the official manuals, which are amazingly well-written. All in all, I'm grateful for Emacs' extensive documentation and the fact that it's available online as HTML, though today I just use Info from Emacs. I've also wanted to learn Emacs Lisp for a while, and the "tough" part wasn't the fact that it's a Lisp, especially since at that time I was already very deep into Common Lisp, but just the fact that you're trying to learn a new "language" and figure out how Emacs models the world (buffers, hooks, keymaps, local variables, etc.) and how it all fits together. It takes a while to collect and become aware of all of the different operators -- save-excursion, save-restriction, goto-char, etc. -- and just the way that the "Emacs API" works -- sometimes the current buffer, sometimes the buffer that's the parameter, etc. There's quite a bit of legacy to deal with. :-)Starting out with Elisp as more than just copy-pastingElisp was odd. Coming from vi, it made me nervous not being able to type ask the arguments to a command at once in M-x interactive functions (`:align ,` vs `M-x align-regexp ...` Prefix argumentKeybindings, odd naming (frames vs windows, yanking), how kill ring works, adjusting to elisp.hard first steps to customize it to my own needsSix months hit to productivity but the people who had the dev jobs i longed for used it.- learning lisp - understanding the startup process and how elisp accesses emacs functionality - strange naming conventions of elisp functions in many build-in packagesconfiguration was complexdevelop muscle memory, create a mental model of how emacs worksthe horrible language used to customize itPerhaps strange keybindings, so long ago I can't remember!The keybindings were difficult to learn at first. I still struggle sometimes configuring my Emacs.Overwhelming number of configuration options. Many ways to do the same thing so hard to know what is the best way. Lot's of state in Emacs that is hard to overview.Going from vim to emacs with keybindings and no .vimrc and no easy package managerJust a general feeling of not knowing exactly where to look for information at first, but then I realised that Emacs has great info documentation and discoverabilityremember key combinationsOut of box, there's almost no support for a new user. If you're comfortable reading elisp there are more tutorials, example configs, and packages out there to work from, but for anyone who isn't already a confident programmer the learning curve is vicious.I struggled with how to set it up, whether you should use use-package, where packages came from (ELPA vs MELPA), etc. I was a very new programmer at the time, so I had a lot of holes in my general knowledge of computer/development environments, which feels somewhat required when learning Emacs.It has a learning curve, with the interface and many hotkeys. Over time it wasn't a problem, but it is an investment up front.Terminology is dense and archaic, manual is intimidating (huge and filled with aforementioned terminology), many default keybinds are uncomfortable and non-obvious, elisp syntax of non-obvious purpose and name (sharp quote, backquote)Keybindings are difficult to remember if I don't use it for a few days, and I had difficulties understanding all the possible commands and the included packages as there was no guide for themThe keybinding wasn't obvious. But luckily it's available natively on macOS and Linux: C-n, C-p, C-f, C-b even outside of Emacs like on this survey using macOS Safari.It is 'different'learning key-bindingsShortcuts, managing windows, missing tabs (back in v26), different indentations per major mode, default scrolling.Finding time to complete the tutorial. I don’t think I’ve finished it yet.Hard to uplift to non modal from vi. Lack of explicit info about meta keys mapping to choices on keyboard at hand (adm5)Remembering all the keystrokes is difficult. The which-key package (https://github.com/justbur/emacs-which-key) has made a huge difference.Very slow loading times (5 minutes while loading files and environments) Many crashes (10 years ago) Basic IDE functions (e.g. navigate to function) missing, or much worse than contemporary code editors.Elisp is still missing some HOWTO docs, the internet tells a lot of old-fashioned ways to do somethingSince I had no idea where to start, I decided to go with Doom first. After half a year I started to build my own configuration.maybe the learning curve i think emacs users should write more blogs, and make online content to help new comersLearning all the bindings was tough. I bought a pamphlet from the GNU store which had on it a lot of helpful information, then I was happy.Hard to remember keybindings at first.- that initial screen is bad and outdated, so Emacs did not look any attractive, actually the opposite. What Emacs configuration distributions (Doom, Spacemacs) look like was what attracted me instead - Having to program (extensively :) to have a nice setup, so instead I, like many others, end up jumping to using Emacs configuration distributions; many others just give up, which is not helping free software culture spread at all, but the contrary.Weird keybindings, weird nomenclature (buffers, windows...)The defaults are rather poor and a bit antiquated. The included package manager, while functional, is simplistic to a fault.Package management and to a lesser extent, customization. I was never exactly clear on how to install and keep packages updated.It was slow on the machines of the day, GUI was awkward changing from Windows.changing the gnu formatting in c mode wasn't that obviousPackage discovery can be difficult; I don't have any language server support set up yet, and I'm probably going to have to do a bunch of reading to figure out how and what package to use. Terminology was/is somewhat different from "standard"; where emacs has a "Buffers" menu most programs have "Files", for example. It's particularly noticeable around window/frame management. The "you could also do this with C-* M-*" modeline comments are too subtle for early learners, I think; the text is transient, and if you don't know to look for it you can easily miss it. It would probably also be helpful to make "describe-binding" and the like easier to access for new users.When it doesn’t workThe conceptual side: buffers versus files. The depth of knowledge required to customise. Weird keyboard shortcuts.Completely different set of keybindings from all other programs.Remembering the key-bindingsI had difficulty understanding how the default configuration worksKeybindings (especially C-p C-n) felt very awkward at first.Everything PerformanceCUA keybindings don't work in minibuffers always and lack full functionality compared to other editors I was used to (e.g CTRL-A to select all) Buffers were difficult to get used to, I'm still not really used to it (I prefer tabs, there is package for it though) Selecting text with the mouse doesn't work like in other editors (if the text isn't visible on screen anymore it won't be selected) LISP wasn't similar to other C like languages, so it took some time to get used to.Lots of options causing analysis paralysis, wondering whether to use a distroDifferent keybindings than what I knew at the time (win)I originally started on Windows, and the keybindings were very foreign to me.I didn't know the customization options and commands so I looked up a lot of stuff online, watched video tutorials etc.Transitioning from Doom to a custom config was a challenge due to having to learn the elisp paradigmNeverending. :)it's ugly. customisation systems are terrible (do i use custom or not? what's this lump of code now doing in my config file? etc). awful default indentation behaviour which is much too complicated to changeKey combination are terrific when you know them but for a beginner they are extremely difficultLack of tutorial style documentation.Weird keystrokes. Emacs newcomers should FIRST customize their own keys, either by selecting a predefined keymapping (Windows or Mac like), or by customizing their favorite keystrokes in a convenient way.Getting stuff like jumping to class/method definition or see its usages. Eventually I solved it using a combination of projectile-ag, LSP and dumb-jumpNomencleature and Keybindings - These are not traditional (used in most modern software editors) and thus the learning curve was bigger. Additionally the freedom to tweak and customize made me put in more time that I would have otherwise.Many keybinding, the default is boring.Emacs Lisp is strange to beginners, and the editor is not very intuitive compared to VS Code and Sublime Text.I had no idea how to start. I watched a screencast of someone programming Clojure with Emacs, and I wanted /that/. I tried vanilla Emacs first. But it didn't give me the experience that I wanted. And I didn't know how to build an Emacs configuration that worked. I searched around, and found Spacemacs. And I was able to discover how it worked. SPC, then watch. Look. I moved to Doom Emacs later.(E)lisp is not easy.I guess the amount of options you have, even initially, might scare some users (such as myself) without a lot of time to dig into documentations, so I took a little longer learning Emacs before I was able to make it my main tool.First it was the default keybindings. Then customizing ie. learning elispThere is no easy guide that lists all my choices for things so I was kind of lost. Like choices for keybinds for example. Also the out of the box experience could be better.It’s Emacs…- buffers closing, text disappearing, couldn't find saved filesFirst, the universal one: Keybindings that differ from everything else one might use. Honestly, I got over this quickly, but without a Space Cadet keyboard, we all have simply adapted to finger gymnastics. Once you adapt, everything else feels odd; but are default bindings actually optimal? And two more that I remember clearly: 1. Lack of an obvious way to see what buffers (at the time I would have thought "files") are open. Most editors have tabs or something similar. Vanilla Emacs doesn't do much for the user here. And buffer listing/switching in vanilla Emacs doesn't differentiate between buffers the user specifically opened and others (messages, help, errors, etc) -- this feels very "noisy" to a new user. 2. The difficulty in arranging windows and making them "stay put." Related to this is having Emacs remember which window the user expects specific buffers to display in. The default behavior felt to me as a then-new user like buffers display "wherever Emacs feels like it."Learning the architecture and the “proper” ways to do even simple things1. A lot of unintuitive shortcuts, that don't have much of mnemonics nor (easy to follow) logic. 2. Learning unique to Emacs editing concepts. 3. Learning how to configure. Then also extend and program it.Elisp and most guides just recommending a particular framework for beginnersOpening files with long lineschange the key bindingConfiguring Emacs is a huge pain. The vanilla setup doesn't have all the features I wanted. Luckily, there was a pre-made setup with almost everything I wanted (Doom Emacs.) Also, not all features are as polished as a proprietary app might be. For example, I think relative line numbers causes lag on my windows machine. Learning some of these quirks takes time.default undo behaviour, features were hard to discoverI didn't like using the built-in tutorials/help so I had to look everything up. Also wanted basic copy/paste to work, both within Emacs and between Emacs and macOS1. Learning elisp. 2. Get to familiar myself with the concepts of buffers, text properties, etc.Most difficult: getting used to the keybindingsOh yes. The default configuration of Emacs does not benefit it. There are a log of extensions overthere, and several make sense when used together. Spacemacs, Doom Emacs do a great job at simplifying since by just "asking" the user "for which language do you want to write".I found the complexity of the customization interface rather intimidating, especially for things that are very simple or built-in on other systemsThe nonstandard key bindings, the out-of-date GUI interface/menu.how to quitI simply did not understand it and what it could do. I wouldn't have switched if it wasn't for doom emacs and org-mode. If org-mode was available on a different platform, I would have stayed on it.elisp is tough at times, some advanced features have a steep learning curve, obscure key bindingsFound no nice and short introduction, but only big onesDifficult getting used to the terminology, setting up emacs for programming languagesFiguring out the indenting system was difficult.Write in emacs-lisp what I want to do- figuring out how to customize it - the key chords are a little bit different than "modern" softwareNo idea, it was decades ago.No, as I was first introduced to Emacs through Debra Cameron's book, "Learning GNU Emacs," which does an excellent job of getting one acquainted with vanilla Emacs.Needed to wrangle some lisp to make org-mode behave.I couldn't find a keyboard with a Meta key.ELISPToo many conflict between packages, and I first used spacemacs, that had many bugs. Still a bit the same with doom. But things are better and better.slow down the edit speedSpacemacs was confusing and abstracted too muchcan be tricky to track down just what code gets run whenWhen i started the documentation on the internet was very sparse.I had trouble figuring out how to add new external packages to doom emacs. I also had trouble setting up the emacs daemon in ixos.No, but I started out on a Lisp machineBefore using purcell/emacs.d and evil mode, I found the Emacs keybindings and terminology counter-intuitive to vim users. Once I was able to integrate those packages and settings into my workflow, things became easier. I still struggle with packages and understanding Elisp well enough to make my own setup but I am getting better. The book on Mastering Emacs helped too.It had a very different set of shortcuts to the conventional ones.I had originally encountered emacs in 1994 on SunOS as a vi-golf enthused EE. The experience at the time was, without doubt, eight megabytes and constantly swapping. This kept me on vi until 1997 until the need for keyboard macros, lisp refactor edits of C++ across hundreds of files necessitated an editor with multi file support trancending vi % operator. vim then arrived on the scene as relative joke, and I just kept working with the competitive advantage that an emacs expert carries in our industry.I'm still learning Emacs, but it's hard to be as efficient as I was in Vim for text editing specifically. I tried evil-mode, but when combined with things like magit, I frequently find myself falling into buffers that I can't my way out of (vim key bindings) and then I get lost. I know there is magit-evil, but having to have a *-evil package for all other packages feels heavy. I've been trying to learn native keybindings, but it's slow going. Other than that, I find myself frequently not knowing the "emacs way" to do editing tasks. How do I, for example, indent a block of text that I have selected by 4 spaces (regardless of auto-indent)? auto indents (but I want it to go further). indent-to-column only does the first line of the selected region. In Vim I could vertical-column (C-V + I) or use `>>`. Do I need to write elisp? Another example is find-and-replace on selected lines (:start,end:s/re/new/ in vim)--I just gave up on that one rather than have it break the flow of the prose writing I was doing. These kind of editing tasks mean I should probably give Evil another shot (to get the vim-isms when it comes to text-editing, not just the key bindings). I'm sticking it out to learn Emacs a bit more primarily because I'm interested in Lisp and the notion of having a platform/ecosystem instead of just an editor (vim).The esoteric keymapping took some time, and then having to learn elisp to fully customize everything.Elisp quirks Inadequacy of built-in package management, project management, source control features Lack of Vim-style bindings (and incompleteness of community solutions e.g. evil) Large variety of configuration options Difficulty of choosing among numerous packages with overlapping functionalitylearning new keystrokes, and the sheer amount of options/opportunities.The biggest difficulty I faced when initially learning emacs was scrolling through pages of code in a way that was intuitive legible. Having it jump from one page to the next made it really hard for my to understand what I was looking at and piece everything together, so I added a scrolling function that allows me to use the mouse wheel to scroll 2 lines at a time, which resolved this for me.The keybindings are really unclear, especially for non-english speakers who don't know what CTRL/Meta?(alt) isFind where .emacs is.It can be tricky understanding elispremembering shortcuts, understanding elisp. Finding out what I can do and how I can do it.Buffer management and buffer persistenceThe profusion of solutions to address one problem can make it difficult/lengthy to find the one adapted to my use-case.it took me years to go beyond text editing and realise that there are many packages available to extend EmacsDefault keybindings have conventions that are too distant from the usual for other programs Elisp was a significant barrier Accidentally suspending Emacs via C-z was surprisingI learned the basics a long time ago before CUA was all the rage. So learning Emacs was just as difficult as learning any other piece of software. Actually learning Emacs was easier due to the available documentation.Lisp is differentRealising what wants attention when something isn’t working.Copy/paste issues with system clipboard.Difficulty moving from customizing via the built in feature to a programmatic approachGetting good initial setupEmacswiki is just bad. #emacs is sort of helpful for learning and more of a socializing place. Generally, learning Emacs Lisp is more difficult than it should be. I eventually ended up having to learn to be a far better programmer (reading the source, being persistent with looking up info, getting used to the weird tone of the documentation, ...) to accomodate.Terminology. It's frustrating.Have a ready to go version (with minimal useful configuration)how to configure slime and lisp sub-process how to load packages and from MELPA or from whereProper configuration syntax, elisp, and modern best practices (i.e. "require" vs "use-package").* Conceptual mismatch - various terms and concepts were not well defined or conflicted with usage in other contexts. eg Buffers.The key-bindings mostly, couldn't use the normal copy ctrl-c and paste ctrl-p. I was terrified by the start-page and text-based settings as well, because I didn't know those text-based fields are clickable. Also I found it hard to navigate (even close it!).I joke that Emacs has a 10-year learning curve. Given that I'm continually learning new capabilities after almost 30 years indicates that's not really a joke. Honestly, I did not find learning the foundational basics any harder than other complex software.Not specific to emacs, but I had (and have sometimes) issues with some packages.unusual terminology (buffers, frames, modes, advice) and assumed technical competence (particularly around lisp) were impediments to learning more. I was using emacs as a file editor (I knew open, save, close, quit) for close to a decade before I started exploring it further.Learning a new keybinding set, new terminology in the documentationKeyboard shortcuts are weirdGrokking the basic concepts was difficult. Needed some time ( ~1 week ) to get to a "usable" state.Vanilla install is quite offputting compared to modern editorsdifferent naming, keybindingWhile initially learning emacs, I felt that the editor was very bare bones. The documentation was great, but i felt difficulty in discovering packages that support my programming language, or what was the general setup that others use. Emacs could greatly benefit from a manual that helps you move from an emacs framework like doom emacs to your own configuration.Advanced lisp language features can be confusingYes, all of them; all of the difficultieslisp, garbage defaults, weird keybindings, emacs pinky, terrible interfaceNot many good tutorials on itUnderstanding how packages work and how to load and configure them. use-package greatly simplified this process.modifing keybindings is difficult (many functions)a lot of configuration is needed before Emacs feels comfortableLearnign to program in elispOut of the box experience for some languages required tweaking and looking for answers in the web, some of which were outdated or didn't play well with my setup.What could be called archaic key combinations especially if moving from a solely MS Win environmentTutorialIt was a little bit difficult to understand the config file without knowing elisp.The default keybindings took some to get used to. Some of the default settings and behaviours of vanilla differ from most contemporary GUI text editors.Sometimes finding documentation is esoteric, even if it's easy to "get to" using C-h C-* it's not easy to understand what to look for, or what certain variables doThe info viewer was not great (in 1996)customization can be a challenge. solution are quite version dependent. there is no centralized resources.I was using emacs before Sublime Text.It's options or settingsProbably tweaking .emacsI had trouble with understanding what MELPA and friends was, as I was also fairly new to programming and the idea of loading other peoples' libraries. It also took some time to gain intuition on the different basic concepts such as window, frame, buffer, minibuffer, point, region, mark, etc.Emacs Lisp, keybindingsAll of my colleagues started making fun of me when I started using Emacs.This is long ago and was before we had Google and all these things and no one else around me did use it - so it probably took some effort. But I don't remember much from that time, so there is no trauma left :)how to exit! (in 1992, it wasn't obvious) what I could actually do with it; no menu mode back thenFiguring out what’s blocking the process. Debugging packages.There were a lot of things I had to figure out at the same time, in order for me to get up to speed with Emacs and get productive use out of it. Ranging from "how do I copy and paste" to "how do I keep Emacs from "littering" my file system with auto-saves and auto-backup files" or "I would like to have a monospaced font for source code only, but for other text I would like to have a font that is easier on the eyes" (less "wide sentences, not monospaced). In the beginning the learning curve was pretty steep!in my opinion, the main difficulty is its configuration language. Elisp has a steep learning curveArcane defaultsslow (especially LSP), default completion/code editing experience subpar, keyboard bindings barely visible (calling commands each time is cumbersome)Too many things to learn all at onceIt was very hard to make it look pretty, having zero knowledge of LispTutorial suggested using C-p/C-n/C-f/C-b instead of cursor keys. Because of that, I delayed using Emacs for a while. Some months later I went through the tutorial but used cursor keys. I didn't like being told to change my habits at the first encounter.Steep learning curve, had to force myself to start using it.Not knowing how to start customizing it to look like a modern editor. I was coming from Sublime Text 2 which was really polished out of the box experience and Emacs' initial configuration and presentation is really ugly.not coding enough. Switching between many problems (often looping or repeating cycle the next day) without solving any one of them.elisp and arcane defaultsCounterintuitive keybindingsI've struggled a lot with keybindings.I didn't know that C is for control and M is for alt.Some keybindings, switching buffers on macos (like ctrl+tab would switch tabs on normal apps, here it is a new keybinding).making several packages work well together, such as autocompletion and snippets for instance.Finding stuff that works with old versionsBeginners can get drowned in choices and people telling them to use evil mode etc. They should just use the defaults and tweak when no longer sufficientInitial lack of tutorial resources (c. 1990)The many different key combos The many different modesThe default key bindings and frame/window navigation were not initially intuitive.It's keybindings, I like the idea that most inbuilt keybindings are C-x prefixed and user ones are C-c prefixed. But they are really awful for your hands. I prefer leader based one's. Also Elisp is really tough for newbies.I experimented with Emacs for 15 years off and on before adopting it. I moved from default to Evil to Xah-Fly-Keys in order to find something l liked. Org formatting didn't seem optimal until I started using org-indent-mode.weird Key-Shortcuts, lack of Elisp-KnowledgecombinationsElisp is not beginner friendlyKeybindings, understanding and leveraging the self-documenting featuresUsing elisp to configure emacs can be confusing at first.undo and redo actions. to move in frames.Default key bindingsLearning the key bindings, and discoverability of features was very low until I stalled helm.Windows setup. Default config looks like garbage, but the “distros” are really heavy and make it hard to figure out what is an emacs issue or a distro issue.Some of vim keybindings were not available in evil- Emacs didn't match my ingrained habits (e.g. I'd press C-v to paste and find myself somewhere else in the buffer) - Learning the main commands/chords I need - Extensions that didn't act the way I expected (e.g. trying to use TAB to autocomplete in Helm and getting a surprising wall of text)I remember struggling a lot, but it was long ago so I dont recall the details.Well, learning curve was quite long. Thus it is really worth the time invested! But I think most people won't be motivated enough to pay that price, sadly for them.The scattering of knowledge across internet to configure properly Emacs and figuring that Emacs wiki is actually out-dated for a lot of subjects.Memorizing key bindings and initial setupThe selection/copy/paste feels a bit weird.I used a vanilla emacs. The keybindings were strange. Once I found `where-is` and `describe-key`, it got much better.Less out-of-the-box support (on Debian-packaged emacs) for different languages and formats (e.g. YAML, git commits, markdown) than neovim/vim; ELisp is very different to Python so still climbing that learning curveWhen first starting to customize it was difficult to understand how packages should be added and used. I found many guides for individual packages, but not on how packages worked in general. This was even more confusing once I learned that there are different ways of installing and using packages.I still don't know how to use info pages.The keybindings, and setting up development environments (packages, LSP etc.) takesThe shear scale and obtuseness definitely slowed me don’t. Vanilla emacs can almost be considered user hostile without a knowledgeable friend or starter kitSome of the language used in the manual etc was alien to me, felt like I had to learn some history to understand emacsJust getting used to the keybindings was the biggest one. Initial configuration would have been an issue but I started my more recent emacs adventure with Spacemacs and then custom, and then Doom and now custom again. Being able to read through their configurations helped get me started on fixing some of the poor defaults.editing keybindingsThe UI looked very archaic and weird. Keyboard shortcuts were not the usual editor keyboard shortcuts. And memorizing extensive multi step shortcuts didn’t feel worth it while there are so many good alternative editors exist. Also, it looked like I need to do a lot of customization and install many packages to make it really useful. But that needed me learn elisp, which wasn’t straight forward, again, and very different than just editing some json or any of the languages that I was familiar with.Some of the issues persist today. How do I configure packages that I've installed? How do I set the font face? How do I get auto-completion working reliably? How do I create quick shortcuts with abbrev-mode or whatever? I know what I want to make my editor do, I just don't know how to make it happen. And when I start investigating, the path to the answer is so long and convoluted that I either lose interest, or I learn it for the afternoon but then forget it the next day.The default key strokes; learning about naming conventions (e.g., buffer, mini buffer, panes, etc.)Getting it running *well* on Mac is annoying.The defaults are pretty bad. I use Doom Emacs, but am in the process of porting what I want to a vanilla emacs. trying to get emacs setup for a good dev experience in C++ & CL was too hard initiallyLiterally impossible to learn without searching online basic stuff like 'How to find file' or 'How to save a file'. Discoverability is a mess on emacs and to this day I'm not sure if I'm Turning on specific packages, like lsp or flycheck, was easy but debugging them was a mess. I still don't have python autocomplete working well. The wiki was very helpful, despite being quite empty in some aspects. Not a single light theme is good. solarized ftw. Dired did not seem easy to use, I still rely on KDE's file browser or the shell terminal bufferI read an entire book from O'Reilly to understand the power of Emacs. Then I spend a lot of time configuring to just enable modes. Developping elisp is not easy.Different keybindings than mainstream. No real Control+Tab to cycle among buffers.Going from zero to a working config. After I found spacemacs and then doom it was much easier.1. My first attempt at Emacs resulted in me giving it up in few hours because I was not familiar with Lisp. 2. The second hurdle was to configure the modules. If you don't understand ELisp you can't figure out what the copy-pasted snippet does. 3. Next, its not very obvious that some modules can modify the global behaviour when loaded. This causes problems like after opening a file suddenly a global behaviour changes. For a lot of configuration problems, a starter kit like Doom helps a lot.Unusual keybindings Higher barrier to entry for package management, than most "modern" editorsE-lisp was a bit challenging getting into.customization et al. (a good cheatsheet would have helped)I had to change to cua-mode fairly quickly. I only discovered Wakib recently, after many years.Just the learning curve to learn elisp and some of emcas internals about how it works.Installing and configuring some packageslearning default key bindingsPoor discoverability, weird UI, indecipherable errors.Yes, the bar for getting started customizing my own stuff was high, even after learning other LISPsUnderstanding elisp can be a bit of a change as opposed to other languagesKey bindings, buffer management, archaic terminologyslow startup , rendering of large filesThe crappy defaultsAt first I tried using Evil mode, but it didn't stick because I kept running into areas where its bindings didn't fully work. It caused a lot of friction. When I finally made an attempt to switch with the default keybindings, I took some time to make small ergonomics adjustments and have been using it ever since.don't remember 😅default keybindings were hard to use until mapping CAPS to CTRL, at which point emacs opened up to meYes, I knew so few people who used Emacs. I started using Emacs as a result of a Coursera course, which was taught using Emacs. My initial foray into Emacs was challenging. I didn't understand Emacs. Then I discovered Spacemacs and I could suddenly replicate a number of features I was used to - so my productivity was not impacted whilst I was learning the application. I could use Spacemacs as a way to begin to understand what was possible with Emacs and how to approach it. I was able to wean myself off of VSCode and other editors (I still reflexively use Vim in the terminal on occasion) to the extent that I now do all my work in Emacs. All of it. I think the biggest challenge I faced with Emacs was "how do I go from a bare-bones editor with _lots_ of potential to a system I can use for my daily work with very little friction". That was what Spacemacs afforded me.1. I wish I had the concentration to read through the manual, but I don't. So many important concepts are explained so for ahead and the beginning of manual is very boring. I have to go to forums and youtube for everything. 2. The .emacs file was conceptually very hard for me. I usually found explanations like "put in your .emacs file" without explaining details like: - The .emacs file does not exist in vanilla emacs by itself. You have to create one. - It is a script of programming in a language called elisp which Emacs reads every time you start it.Emacs keybindings. Deciding what parts of my workflow to integrate into emacs, and which to use an external program. ex. git CLI vs magitKeybindings, mainly copy, cut and paste. But only for the first weeks of use. And I still do not understand the kill ring and use undo-tree to have undo/redo commands.There are a million ways to do anything, it is often hard to know which way is best, or which way to dedicate time to learning. Look at all the completion packages, which one should I train my fingers on? If you choose wrong you have wasted a lot of effort.Trying to figure out how to make it do the things you want. For example, `fill-column` isn't really obvious... It's kind of difficult to use the self-documentation unless you already know what you're looking for. So you end up just searching it online.Learning the initial keyboard shortcuts, otherwise no.The initial keybindings was hard to understandDiscoverability of featuresBuilding up keybind muscle memory. Following advice on the internet made things worse, actually, so it was especially hard until I started from the built-in tutorial once again.- Emacs Lisp looked very foreign and unapproachable to me, coming from languages like C/C++ or Lua - Because I switched to Emacs from editors I already knew (Vim + VSCode), I skipped reading the documentation and thus struggled to figure out how to use it - I found Emacs to be slow or to freeze/hitch in certain scenarios - when using LSP as provided by the lsp-mode package, for exampleI had a hard time with the breadth of options for any given task. For example, running a terminal in my editor was great, but choosing between the term, shell, and eshell commands was daunting. Choosing a third-party package to solve a problem was equally challenging. Vim seemed to either eat the features of powerful plugins or just be more opinionated, which made it harder to customize the environment, but easier to get started.Awkward keybindings. Strange configuration (elisp).viNot having clear instructions of what to do first when learning Emacs. If you start from scratch, you also have the problem of finding the right tools for your work. An example would be to learn that in order to get the same code completion you have in modern editors, you need to install and configure lsp.It was very alien to a mainframe programmerit's massive system.needed some time until I figured out that it is most efficient to use config by others, in my case spacemacselisp, unusual naming/key bindingsI recall it was hard to understand what is what and consequently where to look for docs/problems (for example, questions like "What is running this buffer under the hood? Helm? What util is running this search, and how to configure it? ... this might be specific to "heavy" distributions like Spacemacs though, to some extent)yes, some receipes just do not work or work as expected, horrible debuggingKeybindings and initial configuration.Finding the correct command or keybind to perform some operation. Understanding variables, when they are overridden, when modes change them, and how to change them myself.While lisp is not that hard to learn, elisp is because its builtins are so alien. In no other language there are car, cdr, setq, cl-loop etc... The language is so bad that distributions feel the need to extend it, forcing the need to understand which utility function is builtin or doom emacs only.- Remembering keybinds, especially when they changed between modes - Not knowing how to read Elisp initially - Getting used to M-w and C-y instead of C-c C-v - Getting used to not having undo on C-z (I eventually jut bound it to C-z, I run emacs in GUI I don't want to suspend it) - Getting used to jumping around between point and mark instead of holding shift and selecting things - Losing my cursor! Actually a huge problem, without smooth scrolling and jumping around with isearch I would lose my cursor constantly -- C-l didn't help because it moves so jarringly it would take me a bit to find the cursor again.Sometimes it is hard to find how to do a specific thing.Find key bindings...The defaults are pretty bad. A very austere and confusing experience. Emacs is much better when configured with a framework like DOOM or Spacemacs* Not understanding some behavior, not knowing what plugin was responsible. My buffers were jumping around and I wasn't sure why. * Configuring org-modeBasically everything was a chore when starting emacs. Part of the fun as well.lack of videos and crash course style blogs to get startedGetting used to a keyboard-driven text editor as opposed to a mouse-driven one. Getting used to keybindings & jargon (buffers, yanking, etc.).i didn't understand buffersElisp, single threadedVocabularyElisp, old and outdated documentations, ugly tutorialsUnderstanding buffers vs windows vs frames. I also had problems with misconfigured lsp-mode which led me to leave Emacs for a while, but it's not strictly Emacs issue.Documentation, tutorials, learning material... maybe because it's not a main stream software is quite hard to start learning how to use it. Default Emacs is also quite difficult on my pinky.Window/buffer/frame confusion, keybindings for Emacs and various operating systems and telnetting somehow interfered with each other (this still happens. Is it me?), didn't lay out related windows as helpfully by default as GUI IDE programs do.Learning Emacs standard shortcuts was hard. I used Eclipse and popular editors before, not VIM.By far, the non-standard keybindings were the biggest issue. Even after decades of use, I'd still prefer if Emacs shipped with a default set of keybindings that more closely match existing standards.While Emacs is self-documented, not all parts of the help is easy to read especially for someone new to programming.I wish I understood Elisp better. Not the language so much as the data structures that make Emacs go. This limits the customizations that I do in practice.Not understanding elisp to be able to write and understand what I put in dot.emacs fileWell it's very different from everything else, but not much you can do about that.elisp was a something out of this planet in the beginning but it passed fastNo, just have to take time to read and learnI never had any relevant one, I swear. I always knew `C-h t`.Ugly UIThe key bindings were hard to remember at first, but now they're engrained into my mind.I had many false starts while using other people's configurations. I bounced off the starter kits; I was turned off needing to learn another layer of key bindings. I had to buckle down and read two books about Emacs: Harley's field guide to Emacs & the Gnu Emacs book from 2007. especially the latter book.learning Emacs-specific nuances like the mini buffer and windows vs frames was a bit confusingLispFrames vs buffers vs windows, kill & yank - basically the terminology of Emacs' windowing pre-dates how things are called now. Elisp is ok, but some things are just harder than they should be.Tried vanilla emacs, was frustrated with key bindings and having to read a manual in order to use an editor.poor defaults on versions <27Key bindings. Things getting in a bad state.Configuration seemed complex when I started with emacs.Discovering mode specific bindings. Debugging errors.Initially, I don't know lisp so I had trouble configuring Emacs for some custom purposes. Then it went fine after learning lisp.keybindings and cursor positioning were difficult but now it's rather that every other editor is difficult and emacs is intuitivei don't recall anydon't make me laughConflicting key bindings between packages (eg evil) Scrolling is still awkward, which is ridiculousLayout of User configuration is very confusing (Where do I put stuff) Docs very specific but assuming previous experienceKey bindings were tough at the beginning, but so worth it atm.Some implementations are highly abstracted to allow for broader application - which is mostly great, but reading the also highly abstract documentation for these features makes them hard to get. Sometimes all you want is quick reference, all you have is hard to get.Before I knew about jump-to-definition and describe-variable. They’reexplained too late in the manual. Also slime helps quite a lot.- Overwhelmed by the amount of keybindings to learn. - Trying to customize fonts for the first time. - Keeping a clean and consistent configuration file.I cannot recall any *major* difficulties. The editor was different from what I used before switching to it. I had to run the Emacs tutorial two or three times to remember all basic keybindings. And it was enough to start using the editor. It also felt heavier than Vim at the beginning.The keybinds were an itial challenge until I switched to evil mode. Seeing the power of M-x and minibuffses also took some time.Configuring support for right-to-left scriptsIMO, barely usable out of the box (if not using Spacemacs/Doom). Before trying orgmode: not really clear, whats the selling point.finding a good comfortable ramp to get my setup together and workingI'm still learning. I have long thought that emacs was mainly a terminal editor, and that the GUI would bring nothing significant to it (a feeling that was reinforced when seeing people using the GUI in videos but ricing it so that it looks more like a terminal, and I did not notice the difference). Now that I understood some of the possibilities offered by the GUI, I too started using it primarily (after ricing it to a more minimal and terminal look, too). I keep using the -nw terminal editor too, though, not only for SSH and headless computers but also because I use many terminal applications that can use $EDITOR and I don't want them to open the editor in a new window (I use a tiling WM and this would be messy), therefore I prefer them using the editor in their own terminal window, which can only be done with -nw. Maintaining these two different uses of emacs sometimes still causes me problems to optimize my workflow.Default keybindings. Doom emacs / modal keybindings are a huge gamechanger.my laziness to dive into lispThe huge time commitment and learning curve of getting familiar with the Emacs way of doing things, package management and configuration, and how to discover built-in packages and commands.A lot, but it was too long agoDifferent terminology (frames and yanking and ...)it is difficult to understand the concept of lispCustomizationKeybinding discoverability, lack of out-of-the-box functionality (since alleviated with 'distributions')It was a long time ago, and I was a teenager interested in things precisely because they were difficult, so it's hard to remember.Lisp was new to me and took time to learn it.The default keybindings are not intuitive, but there are a lot of resources in the community for learning. Additionally, the self-documenting features of Emacs' interface are very helpful.keybindings were confusing, evil vim keys are better imo40 years of cruft and odd choices means Emacs has insane defaults and requires a non-trivial amount of configuration and customization to be useful to newcomers. That's a significant barrier to adoption.Understanding the basic structure of a "lispsian" language wasn't easy been new to those.Workspaces and project managementYes. Key bindings were hard to get used to, and the vile bindings weren't that good at the time. I wish there had been something of a "guided tour" of Emacs that helped introduce a user to Emacs from a use-case perspective. It doesn't have to cover *all* packages that support the use case, just a major one, and a pointer to others. - I want to write prose - I want to keep track of a workflow (TODOs, GTD, etc.) - I want to software development (edit, compile, version control) - I want to do research on papers and keep notes and bibliographies I couldn't figure out how to use it in the context of programming Common Lisp. I ended up being lucky enough to have Kent Pitman give me a 30-minute walk-through at a Common Lisp conference.Learning how to manage debugging, all while actually screwing up my configuration, was a bit complicated. As a newbie programmer it feels like there is this wall of things to learn, even with frameworks like Emacs.Insane defaults, sunk a lot of time trying to drag it into the 90s.It should be prettier out of the box, that's what's stopping many from trying. And it definitely should be faster.EVERYTHING IS STILL DIFFICULTKey bindings were alien, so was the notion of buffers. The tutorial in Emacs spent a whole lot of time with navigation that seemed tedious. My real breakthrough was when I got to study and copy a fully featured .emacs file.It's been almost 25 years, so memory faded. But I think I felt overwhelmed :)Default keybindings doesn't bode well with keybindings known in other programs (Ctrl+X/C/V for clipboard, Ctrl+F for search etc.)Everything: installation, interface, buffers, etcThe amount of information on Emacs was overwhelming. I was unsure where to begin. I did not fully appreciate that getting the full benefit of Emacs really meant learning elisp well. I don't think I would have become a successful user if I didn't find Doom Emacs and its community. Doom Emacs provided a solid starting point for me to grasp Emacs' capabilities and elisp.Vast amount of features, choices and things to learn.I kicked the tires on it a few times before I really tried it. It was more daunting than Vim somehow, even though Vim is a bigger paradigm shift coming from a typical GUI text editor. The key chords were intimidating, and being a pretty fluent regex user, I found the implementation in Emacs cumbersome.key bindings kinda suck, and some obvious features are only avaiable through extensions (e.g. hs-minor-mode)key binding are hard to learn at firstPeculiar keybindings for someone used to CUABeing able to configure emacs is what drew me to it initially, but I wasn't familiar with any lisp before then. Even using emacs more casually, eventually you'll come to a point where writing something in elisp is either necessary, or much easier than trying to piece together a solution from hints online. It only took me a week or so of focused study to become familiar enough with writing elisp and the core of how emacs worked to become confident that I could get it to do exactly what I wanted, but there was a long period of time where I would switch back to the tools I was already familiar with when I needed to get something done quickly. Pre-packaged emacs solutions like spacemacs help with the learning curve a lot, but I can see myself moving away from them in future as I spend more time customizing the installation I have.The keybindings were hard to remember, until I realized that it was similar to other terminal programs like Bash and Python. Which-Key also helped a lot with this.I've still failed to learn elisp and completion interface.Finding the learning resources was hard, because there's basically just the manual and r/emacsThe UI turned me off at start before I learnt how to disable it.Key bindings different to everything elseFinding the names of all of the settings I wanted to change- ugly UI - keybindingsIt took several tries. It only took after I learned vim so I could enable evil and be reasonably productive right awayBad default keybindsNo. I came from a commercial port of Emacs (Lugaru's Epsilon).Opposite. I used emacs for ~10 years as a simple text-editor. At some point, I wanted to do something repetitive and discovered keyboard macros. That led me to try writing elisp for customization purposes, etc. I now maintain an elisp package (imaxima) as part of Maxima.Finding good resources online.Don't remember.Configuration and memorizing keybindings-keybindings -package usage -overall mechanicsBeing aware of different packages, I wasn't aware of spacemacs or doomemacs at the startLack of understanding of its advantagesDocumentation is scattered, sometimes out of date. Third party packages can be flaky or go unmaintained.Awful defaults, nothing worked well on windows, slow compared to vim, distro recommendations confused things furtherLack of examples in documentation.it was 1995 and I was learning on university computers, and I might run out my time slot on the terminals because I accidentally invoked Gnus and it took forever to startthe most horrible initial learning phasemistakenly tapping a wrong key sequence and ending up in a different spacetime multiverse. Learning about Control-G was everything I needed to regain sanity.The keybindings were not intuitive, but I was also coming from a windows environmentLearning curve, strange defaults.Keybindings and feature discoverability, adapting to various languages, elispIt was a long time ago. The learning curve was long, but worth it.Everything being different. When using Emacs for the first time, nothing is very obvious and unlike VSCode, it is hard to figure out how to do something on my own.Learning how to be efficient with keyboard bindings and setting up text highlighting and other functionalities.YesIt takes a while to learn to do things “the Emacs way”. Configuring large packages can be time-consuming.The missing of discoverability trough UI. M-X is great, but having menus would help beginners. Also some simple features such project folder tab, is something default in any IDE but missing when you just jump into Emacs.Yes. Elisp was not something I was comfortable with for a long time. use-package was like magic, all I could do for a long time was just write use-lisp blocks to install stuff.Dealing with tutorials written in evil mode when I don't use evil modeKeybindingens.No difficulties, the documentation is great.The keymap. Trying to rid all documents of tab chars. Getting any kind of project-based file-open to work.Learning the key-bindingsLearning key sequencesIn those times, default keybindings were strange. I think today they're more natural. I also had problems understanding Emacs Lisp (but hey, I had only written C, Pascal, COBOL, and other mainstream languages before).- Emacs Lisp was my first Lisp dialect, so there was a bit of a learning curve there. - Dependency management for the packages I used (I started out with spacemacs) were also a bit of a struggle. -weird key bindingsYes, but it was alright.When you first start, it's difficult to know what's out there in terms of packages. When something you're used to from previous editors isn't present by default it's easy to assume that emacs just can't do that thing.It's really too long ago when I started using it just as a basic editor. Since, I have restarted many times as a basic user hoping to extend use beyond org mode and basic editing to all the other functions. In my latest approaches, I have been confused by the amount of 'floating knowledge' about best practices and 'currently recommended package combinations' that there seems to be.Function or in more general object (auto-)discoverability. Packages like Helm or which-key alleviate the pain, but by definition they are optional.Getting started with writing a configuration and installing packages is not easy, there is no tutorial on doing this I am aware of.Been using it for many years so hard to remember now, but I guess the keybindings - especially of third-party plugins - may be a bit hard to grasp initially but once it gets into muscle memory it is just so much better.Getting over the ugliness of the default UI. Then there were segfaults that I needed to investigate and report before it was usable long term. Also the default keybindings were alien reason why I'm using Evil.I remember getting initially overwhelmed by the number of commands available. I was unaware on the daemon, so I often sat waiting for a few seconds for Emacs to load.Couldn't get used to emacs keybind, didn't knew there were any alternatives, and the idea of creating my own keybind for so many functions seemed dauntingFirst atempts failed due to gap between expectations about usual text editor and what you get when open emacs. Also, out of the box tutorial doesn't say how to configure it have at least basic dev environment.The key binding took some getting used to.Customizing keybindingsLearning keybindings is hard. I can't do that, not even with command I use a lot.Surely keybindingsNothing. Just need to take time.I found the documentation difficult to understand and make use of.Elisp is vhard to get into.I do not like the defaults and it took a long time to learn and configure it to my liking, but it is in direct relationship with the power that comes with Emacs.I heard that editors like Vim and Emacs work better. Tried to switch a number of times before, but gave up every time until seeing a colleague of mine doing magic with text, only then I believed that initial struggle is well worth it.pinkie pain till swapping keybinds became possible, initialization file curn. lisp intro like eev was missing...Putting together stuff like syntax formatting, autocomplete, syntax checking for any new project is an arduous task. Without stuff like prelude emacs, it was very hard to get the right elisp in place.The default keybindings are very unintuitive for someone who's not used to them, and it was pretty hard to find good setup instructions that were Windows specific.changing colors and fonts with the guiELISP! Just so hard to wrap my head around it. I see the potential beauty, but it feels like I need to relearn programming. The debugging experience is overwhelming and I don't know where to start (usually paired fixing some obscure issue from some package, that I somehow broke with interactions in my config). So in total it's hard to make emacs run smooth with complex IDE features, especially LSP+DAP mode. In general there's just way too many exceptions when trying to configure things. E.g. org mode: I configured keys for +workspace/switch-left and right. Making these keys work consistently across org, regular files, special buffers, dired etc. is just inconceivably complex!The UI looked very dated. The keybinds were weird from any modern editor. The built-in tutorial was too long and didn't give me answer to "how can I do X like in editor Y", at least not immediately since a beginner doesn't want learn how to use Info manual before he can get his works done. I had to search online help and found that Xah's practical Emacs guide (http://xahlee.info/emacs/emacs/emacs.html) was very helpful and helped me a lot back then.idioms used for eg kill and yank instead of copy and pasteBack in time it was crushing easilyA lot of things have strange names. Like frame/window that is the opposite of HTML. Calling truncateline what everybody call line wrap etc.Memorising the keybindings was a big challenge. Went through the tutorial more than once in order to get used to how to navigate. The other big challenge is window (not frame) management. I can do it but I still don't feel 100% good about how I manage my windows. The packages `windmove` and`buffer-move` helped a lot but I don't have a solution for taming where and when new windows pop up.I didn't care about Emacs keybinds at all and still don't. Lisp is fringe, so why get into it.still don't really understand how it all hangs together. Most documentation seems really old and for ancient packages that people don't use anymoreI initially tried Emacs on Windows 10 via Spacemacs. It was difficult to install and I think I ended up installing it via WSL2 and graphically remoting into that instance. This had the annoying problem that suspending the laptop would crash the X server of the Linux instance and thereby crash Emacs. Ultimately this lead me to install Linux on my laptop. Though I guess this does not really have anything to do with learning Emacs itself. I actually do not recall any specific difficulties learning Emacs which can probably be attributed to me having learned Vim keybindings before and using them in Spacemacs. Another thing which greatly reduced the pain of learning all the keys under the leader key was the which-key package. I have since used Emacs with both Vim and vanilla keybindings and do not really have a preference for one or the other. Though I probably would not use vanilla bindings without home row mods on my keyboard. Evil with space as the leader key makes for a much nicer user experience on a 'standard' keyboard.Default keybindings were not beginner friendly. CUA helped transition the muscle memory. Package management was fragmented (use-package improved that for me).The reference materials (Emacs and Elisp References) were too large Some gatekeepers in the community Lack of knowledge regarding mailing listsConfiguring c++ development environment perhapsHad to start using it three times, I had real issues with navigation even after doing the tutorial. I went back to using the arrow keys. Third time I got it right though.Different terminology for everything (frames/windows/buffers etc).Learning its architecture or “how it works”Since it behave completely different than most other programs, one has to getting used to it. It takes a while to get the mentality which is behind it and the community itself. I'm trying to read the whole Emacs Manual but of its huge size it's taking a lot of time. But doing it step by step works good to familiarize oneself with it. But one has to bring a lot of time with him/her.Key bindings back in the '90s non-GUI late 90s early 2000stoo many useful packagesInitially difficulties were related to learning keybinding, elisp/lisp in general (when customizing), use builtin documentation (info, apropos, C-h, v, f), keymaps, very confusing still is using Tex modes (and like compilations though not related to emacs itself). Minor difficulties including - understanding faces, understanding major and minor modes.Not really. I cut my teeth on a 1990 era DOS editor that used Emacs key bindings, moved to JED because small and same key bindings, the Emacs when I outgrew that.- Understanding the keybinding notation: C-x, M-x, C-M-x ... - How to install packages.Understanding that there where a bunch of global variables that control the behaviour of the system. It was like my MSX BASIC was back. Nice, but used to the "HIDE ALL AT ALL COST" typical mindset of the bad understood OOP that reigned at the time, was difficult to grasp.The default keybindings are ridiculousvi was a pita and I loved the extensive documentation and onboarding tutorial built-inout-of-the-box defaults are quite bad, starter kits give a false sense of understanding, the surface area of emacs is large & it feels barely usable without having a significant amount of existing knowledge to understand and change things appropriatelyThe in-built tutorial is good. No difficulty as such.Modes in modes in modesSome easy-to-mistype keys have drastic and scary effects Undo/erdo behavior is harder to use / seems error prone compared to some editorsJust the documentation of some of the packages.Early versions started using the *scratch* buffer (perhaps with a warning, but we managed to miss it). A crash caused us (working with a buddy) to loose 2h worth of work.memorizing the keybindsGetting past the initial sense of overwhelming.More than a decade ago I tried to use Emacs but I was too impatient, and didn't really need fancy features, so the multiple-keypress commands were too much to bother with. Recently I started learning lisp, and I also now have more patience to learn new commands for an editor.being used to bloated GUI apps makes it hard to understand emacs in first placeRemember more key bindings. I can only easily remember simple ones at the very beginning, e.g. move up and down, open file, exit emacs, and the m-x.It's hard to write Elisp to customize and integrate different packages to make Emacs easy to use. When I find use-package, it's become easier.Learning the keybindings, it was my first exposure to nonstandard keybindings. I still have no idea how to customize emacs to the extent I want to.Learning the keybindings, finding all the packages to have a good experienceYes, it was a bit esoteric with Elisp but then I took a Lisp class and it made more sensenot knowing some keybindings or functions to navigate large buffers (e.g a hug shell buffer)Learning all the key strokes to be efficient and learning about buffers and moving between them.Can't remember anymore, maybe....A large number of completion frameworks were confusing. I couldn't understand the difference between company, ivy etc.Cygwin, iOS can be trickyConfig editorI think my biggest hurdle was setting up package.el for the first time without knowing what melpa was and how to use itremember basic bindings but which-key saved my a** and understand e-lisp to configure and combine the different aspects of functionality properly but overall was lucky to have the time to dig in and understand some stuff. Otherwise it is difficult to move on this philosophy!! Glad that i did...Keybindings seemed bizzare at firstRemembering the key-bindings; package installation, configuration, and usage; repl integration with (interpreted) language (e.g. Lisp, Ruby, or Python).Getting used to keybindings, default settings are not ideal (eg terminal bell)window managementcomplex configuration when first time usingIt is hard to write your own elisp function.Learning new bindings can be tough at the beginning. Especially with cut/kill/yank/pasting.Documentation is not cohesive, straightforward, or geared at beginners.Not having the tools for debugging my init, those were the Bad Years. I relied on crude methods like bisecting, and didn’t feel confident I owned my Emacs. Like inheriting a rusty aircraft carrier with holes and one retired crewman nicknamed Slow Ben with faint memories of how things used to work aboard but interrupts all your questions to talk about boiled cabbage.There was not since it is well made by Stallman.Elisp, keybindings, laggy plugins which block the entire UI ( IMHO it is currently the big drawback of Emacs ), a search on a big file can block Emacs for few secondsKeybindings don't match those of modern mainstream editors. For some applications it was slow (e.g. opening very large files) -- nowadays the experience appears to be better.I'm still initially learning Emacs after 4 years. The learning curve is the biggest difficulty: being unsure where my configuration lives, not knowing why a package update breaks the whole editor, not understanding how to see all possible keybinds for the mode I'm in, and not having a solid understanding of how to interact with the Elisp interpreter underpinning the whole editor are a challenge. I use the Doom framework to have an editor that at least resembles something modern, but although lightweight, it still adds a layer of abstraction between me and Emacs so that adds to my difficulty. When everything is working, I feel confident as a user. As soon as something breaks, I don't know where to look for that breakage and resign myself to internet searches to fix even the most trivial things. I'm not a programmer or developer by day, and so when these things happen in my day job, I typically have to put off using Emacs until I have the time to investigate.Tried setting up gnusIt took a long time to wrap my head around the default keybindingsElisp wasn't intuitive for me as I write mostly Python and knew some vimscriptArchaic, not ergonomic default bindings and settingsConfiguring the modes for the language utilized, finding & adding packages for IDE-like functionalityDebugging init.el breaks (didnt have config under VC) Organization of large config - ended up doing an init.org with babel Latex auctex/org mode configuration of file output. (Org to PDF, and TeX to PDF in general) - condense output, etc. Getting keybindings set up that I liked Still havent set up LSP or dap debugging properly, because I could never figure it out. And I dont want to use doom (although I've tried it), because it sets a bunch of configurations that I didnt ask for. So im using vscode for code editing. Its not a priority for me atm. Trying to make Emacs do something it cant do well (org mode with images - where it doesnt have pixel scrolling, and images jump. Pixel scrolling mode is too slow.)i had issues with understanding how to install packages. my initial configuration was only theme, and adding reverse kill line binding. Mostly configured with the GUI. I could not understand how to connect to elpa/melpa to install anything.Understand Elisp to configure Emacs. KeybindingsElisp, key bindings, lack of good tutorials back thenThe keys are kinda crazy. Takes a lot of effort to overcome.Setup the key bindings for functions, key bindings.Documents tell me almost everything for Emacs but partially localized. As long as I'm Japanese, my first task was to obtain rudimentary English reading skill.Elisp is a bit difficult, and setting up a repl for the first time was strange and difficult.A lot of the window management features were a bit confusing, and I found it easy to get stuck in situations where I couldn't figure out whether to kill the window, buffer, or frame, as some things were transient and others were not. Also remembering some of the M-x commands that don't always have straightforward names, like "visual-line-mode" for turning text wrapping on and off.Remembering key combos, finding a satisfying client/server setup.Copy paste is very different from standard, key bindings don't work as expected (ex. Ctrl s doesn't save), exiting tui is hard until you know the basics- How to properly find help - The vocabulary used in the documentation is still obscure from time to time - Elisp still does not feel natural to me (hope it will some day) - Lack of online videos / tutorials (which has greatly improved now)Keyboard shortcuts make life easier but take time to get comfortable withComing from vim, took me a while to build muscle memory for the key combinations.There‘s a lot of documentation, but it was not always clear what I really needed to knowPackage management was difficult to comprehend/setup (MELPA).Keys and ConfigurationKeybindings + configurationdocumentation was hard to find. i had to follow peoples tutorials.Confusing keybindings, weird terminology (buffer, frame, minibuffer)It was really confusing to setup configs.lisp configuration keyboard shortcutsTried it first in the early 2000s. It looked ugly, had non-anti-aliased fonts, was slow, and the keybindings were hard to learn. Never got to understand the power of its extensibility.Discoverability (unless you read the manual)Sure there was a gazillion keystrokes. But I just sat down at the tutorial and later the info to get good.Learning elisp was a big hurdle.keybindings and buffer switchingi don't know how to config emacs( i don't know where .emacs.d is.....)Everything. Keybindings, package management, learning about best packages, dealing with issues that occurred.- Not being sure how to modify or extend the base configuration, as I wasn't sure how to read/understand emacs lisp and/or configuration settings in the .emacs file and also since I was afraid of either (1) breaking the system or (2) copying and pasting (or rather killing and yanking :) ) malicious or insecure code - wanting to get involved and not knowing how to find the mailing list for emacsThe bindings felt different.It’s been over 20 years, can’t rememberLearning to use the key bindings to navigate. Also the UI looks completely different to other text editors so it takes some time to learn your way around.Fucking with elisp was way more fun than my jobi never use numeric prefixes defaults i still ahve not figured out what i wnt in navigtion and killingLack of simple examples in the documentation.What the key binding again?Starting from no programming experience, just the idea of a config file and lisp was difficult to graspCommitting key bindings to memoryDifferences between frame, window, and bufferLearning the keybinds. I wasn't taught looking through M-x at the time and I don't know if when I learned Emacs there was a good/easy way to narrow M-x completions nor did they show keybinds.difficulties in confguration of keybindings on Linux and MacOS, terminal and GUI uselack of descriptions (signal to noise ratio is not good if you are a beginner)Sometimes it seemed too customisable. It took me quite a few tries before I tamed Gnus, for example.I started with the tutorial as a starting point, that got me all the basics to launch and start as I did on my previous text editors. Then, I stayed many years with just the basics, just because I didn’t know what I could do from it, neither did I have time to learn deeper. I learned a few tricks sometimes, either shown by some people, or by trying stuff in the menu, but I really used it as a basic text editors for years. I also never got really what was beyond buffers, how to deal with frames and windows. Someday, I heard about Org-Mode, which I tried and found at the same time very pleasant and answering a profound need of organization in a way I would never imagine. This led me to really customize emacs for the first time, mainly by imitating. I also learned about the "M-x" feature at that time, and all became clear. I really wish I knew that earlier. Now I use the help about functions and variables to learn when I am looking for setting up something. Then, I wanted to go further with ELisp programming, and the difficulty was at the same time to remember the basics of Lisp programming (I learned Scheme at university which was a very helpful to have an understanding of the concepts of functional programming and to love it), then slowly to catch how to interact with the Emacs editor functions. In the end, this is very powerful, it takes time, which is normal, but it is not easy to find where to start or to get a grasp of what are the essentials to interact with the editor and/or the packages. This is one thing I would like to document as it changed my way of living with emacs, but I am overwhelmed, so it’s still a "I would like todo project" :)Table stakes for IDEs like fast editing, syntax highlighting, project navigation require a lot of upkeep. At some jobs I had to ditch emacs for pycharm, vscode so I could remain productive and not spend all day tweaking new packages.Learning keyboard-based workflow, understanding configuration & more advanced documentationI didn't know where to start when I wanted to customize Emacs. I tried to look for something short and quick like "sample customizations" or "what can I customize?" but the reference manual is too dense for this. I was able to overcome this difficulty by spending some time to just read the manual front to back, and look at other people's configs in GitHub.No, I started before using Windows, so my muscle memory of Emacs keystrokes is, if anything, better.The Emacs / XEmacs schism complicated things a little, as it made it harder to find applicable adviceTo get thinking in buffers.Figuring out popular and useful packagesTrying to remember the basics keybindings without destroying all the work done in the buffer.remembering key chords and finding helpToo many features, I don't know how to configureHard to find some documentation, especially on certain packages and modules, configuring mu4e (for gmail in this instance) is impossible for me and I tried multiple people's configurations while changing to credentials to mine. Hard to understand what exactly goes wrong from errors, doom doctor is fine but if you've misconfigured something in your config, it's hard to see what actually went wrong for someone who isn't very proficient in elisp.Having to learn Lisp as the language to configure the editor was off-putting originally, because it seemed like the effort would not be useful outside of configuring emacs (e.g. lisp didn't seem like it had practical usage for my professional life). I've since done a complete 180 on that stance however, as I now prefer lisp dialects to any other programming language and am actively trying to find ways to work with languages in that family for my professional life.No visual debugger lines like vscodeEmacs as an editor vs emacs as a LISP environment confusion.overwhelmed, didn't learn "how to learn emacs" (by that I mean using the help system and how to explore further features after the tutorial ends)Preferring built in documentation was difficult to learn. Would google frequently because I didn’t know how to look for things. E.g. fuzzy matching on ‘describe-{var,func,face}’the default configuration renders Emacs almost unusable for frontend developmentWhen started, I might get lost -- eg inadvertently enter a recursive edit mode -- and have to suspend emacs, kill it, and start again.unusable default settings, especially switching buffers.Weird menu options.Key-bindings are hard to learn, I was stuck with a handfull oft, until Emacs fron Scratch showed me "which-key". Same for commands and minibuffer-history plus Helm/vertico AS well es for recent-buffer/file-historyThe keybindings and conventions (windows, frames) are very distinctive and unusual by modern standards, but I found it easier to just learn them rather than mess with packages that tried to simplify these features. By learning Emacs in its vanilla form, I can install it quickly on a new machine with almost no customization and still feel productive right away.terminologytransitioning from a modal-editing perspectiveHow to customise agenda. How to customise ui and fonts. How to find commands and shortcuts.Manuals in texinfo were incomplete; needed man too much.Emacs is very overwhelming at first coming from a regular IDE, lots of keybindings to learn as well as new vocabulary. Even the very popular packages like `use-package`, `magit` or `projectile` have lengthy and sometimes obscure docs (`magit` and `transient` come to mind)Get familiar with the key bindings.Extreme adaptability comes at a price, can be confusing at first. The popularity of frameworks like Doom are a testament that Emacs needs to do something for first time users; don't disable the menu and scollbars! Crafted-emacs with their modular approach and sensible defaults seem like a good start.Default keybindings felt strange at the timeNot intuitive, high learning curveemacs incudeed many packages. so difficult to choose i use.Learning key bindings. Removing all of the rough edges with packages. Getting all of my languages setup. Autocomplete for C/C++ still doesn't work.Odd keys I still can't remember ^C and 6x bindingsOf course the key chords were a lot at first! And just getting it set up with my environment and all the packages working in my .emacs file. But it was also fun in an obsessive kind of way.Learning default keybinds took a while. Also, configuring emacs without knowing elisp means relying on code I don't understand (like from stackoverflow or reddit).No package managerLearning how basic things work. What is a face? How to change it? How does elisp work? When should I put ' before a symbol. How to hook a function or remove it?elisp syntax is difficult as the error messages aren't that great.figuring out empty combinations to bind stuff toIt has terrible defaults and takes a lot of config to get to a modern, usable state.The keyboard shortcut, way too much to recall without a cheatsheet always next to me.I used to use Spacemacs. Gradually I learned Emacs Lisp and understand what Emacs works from it. Then I started to write my own tweaks. Then I started afresh and wrote my own init.elElisp is not my cup of teaNo, I learned from the built-in tutorial and then learned other modes. I still didn't learn lisp, so I feel that will open up worlds when I do learn it.I just didn't know how to start. I couldn't remember all those commands!Elisp is hard to learn for beginners; the documentation is meant more as a reference than a how to for who does not know the language.Learning various editing techniques, such as search/replace across projects. Understanding what packages to use when there are multiples out there (projectile/project, icomplete vs. all the other options, etc.)discovery of keyboard shortcutsI often have problems with packages that didn't work easily for the windows versioncursor movementsLearning keybindings. Knowing what to configure, what to add to vanilla. There is a lot of really good extension and built in things to use but knowing what to do was difficult. Luckily I found a good youtube tutorial and subreddit to help me.Examples in documentation, both official and package-level. As a beginner programmer, I relied heavily on patterning off of examples, and without them, I struggled to understand how to implement features.Elisp is freakin' weird. Like 'defadvice' still blows my mind.Moving the cursor to another window while the minibuffer is active can be very confusing.Too many optionsConfiguring my own and going bankrupt 3 timesLack of screenshots/examples on package documentations.Most config files use setup macros, straight, use-package, etc. rather than built in capabilities. Setting up keybindings is weird without something like general.elNot, but Elisp learning is a challengeThe biggest thing for me was probably just learning its peculiar antique terminology for everything.nonintuitive (from a windows pc perspective) default keybindingsI had a lot of trouble dealing with the veryb different names for concepts compared to most other programs e.g. buffers vs files, windows vs framesInitially I thought Elisp was a hard language to learn, but once I started reading documentation it became much easier to use. Emacs' keybinds were hard to learn at first, it took me a while to ingraine the keybinds into muscle-memory.variable and function names don't follow a consistent naming schemeTrying to initially get started without using a framework like Doom Emacs was difficult, because the keybindings and configuration mechanisms are unintuitive and difficult to learn.Learning the key binding and that time packages weren't available so it was hard to have a setup usable for working purpose. Having something equivalent to intellij for instance with completion, jump at point, documentation is very important for professional purpose.Keybindings/file & project navigation. The latter was (is?) the biggest blocker to me being 100% comfortable; being able to quickly jump between files in a project (and between projects representing multiple services) is important and not super easy to do out of the box.Coming from vi, it was hard to learn new key-bindings.- Some key bindings (e.g. ctrl+>) not supported is some terminals despite trying many solutions (e.g. iterm) - File Permission issue while working in MacOS - Hard time setuping TypeScript, in fact I've never managed to, I ended up using lsp. - Configuring an auto completion backend - Slow startup times - Use-package is not yet in coreThe documentation on usage was exceptionally good. The difficulty lay mainly with using/configuring other packages. For example, sometimes `python-indent-offset` would get set to 2 not 4 -- how do you fix that?There is a lot of things to learn if you want to understand how things actually works (for example all the text-specific tech and data structures)It is very complex, understandably. How many times have I discovered that a problem is due to my configuration? Thank goodness for Spacemacs!key bindings general power of the beastLearning the default key bindingsIt felt hard to chase down what something does. IE: automatically doing stuff when typing (completion, indentation). What keymap was that on? Is it a function bound to a key or maybe it was a hook? Or maybe it’s a remapped function that overrides a common key binding for this particular minor/major mode. Does that function just apply a different function that’s held in a variable? Does the function in the variable just look at a list of other functions in other variables? With Vim, the path from key press to actual implementation code seemed very direct… it was a “command” (interactive function) or an auto command (hook). In Emacs one needs to write yourself a breadcrumb trail of the functions, variables holding functions, modes and keymaps when looking to inspect or change a behavior.Language Server Protocol (LSP) for PythonI had some difficulty at first finding up-to-date community recommendations for Emacs Lisp packages which would help me achieve my editing goals with Emacs. I also had some difficulty learning how to write idiomatic Emacs Lisp, but found reading the source code of Emacs Lisp packages helpful.Keybindings are not consistent across libraries (thats obvious now ofc, but when used to a curated software experience its totally unexpected) Bottom-top-approach of docs (info) was daunting. I experiemced the "Self-documenting" nature of emacs as true but misleading in that regard, bc it seems often better treated as a reference than a manual. Never knowing when it is "emacs fault" or if I am just using it "invorrectly". That is true for the info manual too. I said it is daunting, but maybe I am just not using the correct interface for it. Not knowing elisp (or any other programming language) made configuration hard (starterkits have solved this IMO)Forcing oneself to learn stuff instead of using an IDE with built-in buttons to click for compiling code, syntax checking etc. built-in.The keybindings were a handful and It wasn't obvious how to use to things with itGetting used to and remembering keybindings that are not like regular OS keybindings.The key bindings were very strange considering every other "normal" program would use the arrow keys and C-c C-v to copy paste.Unusual keybindings. Vi bindings are more intuitive though it's not the most common.Changing from a project and file tree oriented way of navigating to using search and buffers.Not particular. Was always a step by step progress. However, two things stick out as negatives to me. The built in tutorial insisting on teaching you the HJKL movement, which is very foreign to most, instead of teaching Arrow keys. Also the terms used were highly confusing to me. Frame vs Window, kill vs yank, kill-ring, being standout ones that are counterintuitive terms IMO. Lastly, the undo behavior is not well explained at all. It took some real time getting used to.Key mappingNo. The built-in tutorial got me started.Emacs keybind was difficult for beginners.Configuration on windowsThe lack of good documentation on the emacs APIs and internals, and the lack of elisp docs and learning pathsKeybindings, startup time, good defaultsNo, but it took quite a while to realise the full power of Emacs.Before I tried Doom Emacs I naturally struggled with keybindings / commands, because they are different from every modern text editor. I also struggled with installing packages, because I would often find multiple ways of doing what seemed to me to be the same thing. But I didn't go very far before trying Doom Emacs, and I haven't had many problems since.Learning ELisp and transitioning from my Neovim config to an Emacs cofnig that felt comfortableGetting used to the some of the terminology and differences from the OS standard keybindings.Still difficult, elisp is weird Ther is no namespacing for functionsThe default keybindings are very weird on a standard qwerty keyboard. I'm using programmer dvorak right now with C-x and C-u swapped, which is way better.Emacs Lisp. Also old terminology and conventions, like buffers vs windows and frames. Package management and configuration was/is tricky when composing multiple packages together in Emacs init.elThe package loading experience is atrocious and a lot of improvements could be taken from the way vim handles packages, particularly with conditionally loaded scripts. Use-package helps with this, but getting sane lazy-loads should be the default. Documentation assumes strong lisp knowledge and and internal knowledge.Key binding and ElispKeybindings and configuration.Unfamiliar paradigm, used to concrete GUI. Strange key bindings (no CUA? C-w, C-y seems strange!)Self-documenting features are not really that accessible and structured well for beginners. It is easier to start learning about Emacs somewhere else (in the internet).Knowing what it was.Learning keybindings. Finding settings. Setting up every thing so that it works like I want it to, to reduce "friction" and annoyances.As a non-programmer, base emacs is intimidating. Spacemacs made my transition from word/vim much easier. I eventually settled on doom, which is perfect for me.Hand strain from doing default keybindings until I moved Ctrl to Caps Lock and mapped common functions like write-file to the F keys.I thought it was hard to get into Emacs lisp (the tutorial was slow and you didn't get results fast enough). I also thought that the defaults was kind of bad (for transient-mark-mode was disabled by default back then). I think that the defaults are getting more sensible for newcomers, and the various starter kits are probably helping too.overwhelmed by amount of external packages, and stuff inside Emacsthe keybindings are hard to learn for a newcomer and I still struggle with some basic commands that I don't use daily.Struggled with buffers as that was a new concept Configuring to get features I expected in an IDE was difficult until I was introduced to DoomEmacs is difficult to learn, even as a tech-savvy user. The self-introspection works in paradoxical ways: everything can be examined, but is not easy to discover without a prior knowledge of Elisp. Theoretically, this wouldn't be a problem if Emacs were easy and pleasant to use out-of-the-box. Users would tweak Emacs only when they would get to learn Elisp. However, I find vanilla Emacs to be almost unusable, so it immediately requires tweaking, which is impossible as a beginner. Doom Emacs does a good job at providing a pleasant out-of-the-box experience, but I think it should be made even easier for newcomers. It is not because Emacs is powerful that it has to be difficult, and beginners and non tech-savvy users should be able to have a pleasant experience without have to learn much about it.The basics of how to configure stuff.It is a little bit sloppy sometimes, especially with lsp activated (I know it is JSON shit)Too much of everything. TMTOWTDTI started with spacesmacs which was very heavy and opionated and difficult to customize. starting from scratch, it was difficult to find the way I would like the configuration to be done - e.g. with use-pacakge and straight.elTerminology and keybindings, the internal tutorial and cheap copy of Emacs book helped a lot.Learning keybindings took a long time- wish I had started with which-key mode.Different keybindings compared to vi/vim. I decided to not use evil-mode.remembering key mappings. first started using it on a sun workstation (bad unix)New lisp dialectI had trouble configuring Emacs, but that was 4 years ago.I had to customize it a lot to get to a point where I liked it better than other editors (especially Vim) out of the box. I mainly learned Emacs because I decided to really give Lisp a shot (which I had previously hated due to a bad first experience). I learned Emacs to force myself to use a bit of a Lisp in an environment where I had heard it worked well, and because I had heard Emacs was by far the best editor for Lisp. Though I quickly learned that Emacs excels at exactly what I found frustrating about Vim -- extensibility and customization.Clash with plugins, and plugin updatesUnfamiliar KeybindingsDefaults are totally different from anything else I experienced back at the time (Windows 3.1, 95, 98, NT, Solaris, MacOS ). Was not able to just jump in and do anything more complex than simple text editing. It took quite some time until I actually took me time to learn it and start using as my text editor, Emacs exclusively. Manual can sometimes be hard to understand due to different terminology and due to slightly different implementation of some concepts. Emacs Lisp was even harder for similar reasons. API can be quite old in places, and the terminology used back then can sometimes be different from today. It is not an Emacs fault per se, but the way Lisp was used in 70's may be a bit unfamiliar to someone coming from Java or JavaScript of today.Yes, the defaults are a mess.None that I recall - Windows/CUA didn't exist when I first started learning to use emacs.Trying to fit the vim keys. Going all in with emacs keys was the better idea.Emacs is huge. After completing the initial tutorial, I didn’t know how to proceed to get the most out of it. I still consider myself a newbie, as there is always something to learn. emacswiki.org is full of useful information, but the sheer number of possible choices is intimidating.Learning the keybindings Making some parts of configuration work (sync google calendar)Lisp is nice for sure, but there is to much old terminologies in lisp.I still do. Emacs is an Editor for Nerds. I am not one. I want a tool which solves problems, so I can stop thinking about them. I do not care for programming, it's just a tool for me.No previous knowledge of lisp, also was using spacemacs and it was difficult to find what was spacemacs only and what was from emacsFinding the words for what I'm looking forThe sluggishness, specifically when using LSP. I was close to switching back to vim but I kept at it because of how nice it is otherwise.Emacs keybindings are hard.I use Java a lot at work. It's hard to make it like an IDE and hard to debug at first.set up key bindingsLearning all the keybinding combinations and commands to quite a while and is not intuitive.Default keybindingsHard to discover all the features.1. Learning the key combinations (I wrote a cheat sheet and taped it to the side of my monitor for weeks). 1a. Even basic navigation and vanilla functionality 1b. paredit (separate cheat sheet for that) 2. I started with Phil Hagelberg / Technomancy's now defunct emacs starter kit for my config, so it was a long time (years) before I ever did my own config 3. Although I quickly became adept with using emacs as a text editor (navigating around file system, find and opening files, editing, etc.) I did not for a long time understand/appreciate Emacs concepts like packages, modes (major/minor), built-in tools like IBuffer or Dired, evaling elisp. (Probably my own lack of curiosity rather than any fault of Emacs.)I had to learn elisp if I wanted to build my own GNU/Emacs configuration and there was literally no elisp video tutorials in my native language (Portuguese). The community is still pretty small if you don't speak English.Too long ago, really. I was a serious Lisp/Scheme student at the time, so I took to Emacs like a fish to water.Keybindings which spacemacs helps a lot withEverything was so difficult in Emacs, from the weird keybinding to using different packages.I struggled a lot with evil mode, but eventually to original emacs controls and loved it. Had some issues with performance/gc settings because I didn't understand what I had done, but once I learned more elisp and the emacs backend I started to learn how to debug and write my own functions and packages!Transitioning between modern GUI conventions and Emacs conventions, and having to mentally translate actions between the two worlds throughout the dayThe conventions in the manual makes it hard to figure out elisp by experimenting. When do I use a ', when do I use a ` etc.Key bindings : terminal v uiNot difficult, but confusing. Keycommands (used postits) / dired usage / mu4e configurationYes, it was very backwards with the long cord like keybindings, that was 25 years ago...memorizing key commands, configuring OS meta key.Keymapping is hard to remember, and it is a struggle to analyze the debug trace.Probably the reliance on buffers. Buffers in and of themselves are great. But trying to achieve any data manipulation without having to put it into a temporary buffet proved difficult.Yes, the starter packages added a layer of complexity that I found baffling. I have to restart with Gnu Emacs.25 years back, my learning curve was not just steep, it was practically vertical. But I loved the climb.installing packages/add-ons like flyspell because it needed other packages. Easy when you know how, lots of internet searches to figure it all out the first time.Keybindings as usual, but it is easy to get hung up on changing your "default" emacs by copying what you may see others use. This desire to get your config "up to speed" conflicts with developing a solid understanding of what is already available in emacs. Especially with the later releases. This gap between "barebones" custom emacs and vanilla emacs deters adoption, is my guess. Ultimately, if you want something, you may encounter a lot of friction getting there. To the point where you would just give up on it, if there isn't already a package and you aren't interested in making custom elisp.The help system is a skill that must be learned, there isn’t a way to search the Emacs help system from within Emacs easily. It is also hard to know what features Emacs has and doesn’t have out of the box.Viper sucked, I had vim motions as a second language. Elisp docs felt baroque.Understanding the layout of the filesystem. It is kinda obvious now, but seeing the ability to use arbitrary file names to modulate your package management definitely through me off. Performance on windows is spotty, likewise support. Overall, Emacs really good program.Learning how it worked/is intended to be usedThe terminology was very confusing for some time and the fact that there is so many features. At first I found the manual hard to understand but now I can always find what I am looking for. The focus of the learning and many online articles / help sites on the use of keyboard rather than mouse interface is bit daunting. As I have become more acquainted with the product, I do more with it and find the manual provides all I need - external sites tend to over-complicate solutions to some very simple problems.package maintenance.adding and customizing new elisp packages for language supportnon cua keybindingsFont looks ugly and set font is very hard.It took a while to learn the standard keybindings.The defaults were off-putting.Getting used to different keybindings from the ones I usually use.The major difficulties I faced was thanks to the fact that, despite my own wishes, Windows remains my main OS. This together with me being new to Emacs made some things a bit of a hassle to get working, for example AUCTeX (especially synctex) and hunspell dictionaries for flyspell. These were not at all an issue when setting up Emacs on my linux machine.VIM has a more declarative interface, eg, when making selections; the interactive "C-space ..." is kinda klumsyMostly just the initial learning curve to understand it. Was one of those things where you just have to sit down and force yourself to learn the keybindings. Also understanding how to works was a bit of a learning curve, as most places talk about it as just a text editor when there is so much more to it. Another thing that was a bit difficult is that there is self-documentation, but sometimes it feels hard to remember how to actually get that self-documentation. That being said, 90% of the time you can just google the program and find the exact same documentation online.- Sometimes it's difficult to find simple answers to basic things: "How do I get line numbers to show up?" - It's hard to get started with using emacs-lisp to change how emacs behaves. There is no easy to find "start from scratch with these examples and you can make your own configuration changes easily" kind of tutorial. A lot of the content online assumes you already understand many things which is not the case for a beginner. Here, I'm not talking about the language itself but of the emacs interface which is available via emacs lisp. - The path to proficiency is rather burdensome. There's no simple way to build it up gradually while being able to rely on retaining previously acquired knowledge. - The affordance of emacs help interface (overall) is quite weak. - On the whole, there's no "gentle" way to get into emacs and attain proficiency.control key pinky fatigueThe key bindings being different. Even with evil it was a bit of a struggle.still am learning and don't know much about lisp and the actual inner workings of emacs. also used to be much slower before native comp, but more recently has been performing amazingConfiguring emacs at first was challenging, as back then I knew no lisp. For instance, I wanted new packages from the melpa, and installing that at first was challenging. Maybe that's because of the melpas instructions, but back then I had a tough time figuring this out.Keybindings but the tutorial was greatKnowing where to start. The keybindings were odd, based on what I was used to. LSP was fairly new and reshaping the packagescape. I dabble in a lot of things, so it was a task to figure out how to integrate. Actually, a website that visualizes and compares workflows with links to packages could really help people know how they might build a config. Interesting thought, there.Key conventions, and learning how to discover things. Taking the time to use the tutorial, and read the manual was sufficient.I find it hard to debug elisp and understand what's going on.Learning what functions exist to begin with. Seeing what they did is easy using C-h but having people say "there's an Emacs function for that already" without me having heard of it was common.Mostly moving to Emacs keybinds from vim.Understanding buffersHow to save, copy and pasteunconventional keybindings, poorly formatted built-in tutorial, lack of text centering (olivetti-mode), not user-friendly theme, monospace font that makes reading hard. however F1 - i tutorials are very helpful, bc they are like reading docs on webNot understanding how to use the help pages. Not understanding how to translate to/from use-package setup. Buggy setups for popular languages like python.Learning that M-x meant option/alt key + x key! ha ha!Yes! I tried and failed to grok Emacs many times. I did not understand elisp (having never taken the time to learn Lisp) and have nearly 2 decades of vi(m) experience, so I needed vim bindings. What ultimately worked for me was two-fold: Extraneously, I became interested in learning a Lisp, shortly after I found a project (github.com/Susan/emfy) that demonstrated how to create a minimal Emacs configuration that explained every line of the config. That got me up and running. From there, I watched System Crafters videos about creating an Emacs configuration from scratch. After that, I had a firm grasp on how to configure Emacs, how to use Emacs, and how to look up information inside of Emacs, all using the vanilla experience. Then I finally moved over to Doom Emacs and ported some of my own configuration in. I've been using it as a daily driver since.debugging is hardGetting the right mental modal for Emacs. Reading Mastering Emacs Book said it was the tinkers editor "probably amoung other things" and it was a computing environment it clicked for meI found it immensely frustrating how often a carefully crafted window layout got utterly clobbered by some function.Emacs has an insane learning curve. I have been trying to use it off and on for years. Mostly off. I will install it, then try to use it for a bit, and then give up for an easier (but less powerful) IDE. I've tried DOOM and Spacemacs.My vim muscle memory made it harder to adapt until I caved in and installed evilFundamental understanding of elispconfiguration, but then things like spacemacs/doom became a good starting pointThe keybindings were different than what I was used to and I had a weird bug where my terminal would vomit escape characters at the start of buffers sometimes, but I don't remember much of my learning process to be honest. I was 15 when I started so I just vacuumed it all up without thinking.unhealthy default keybindings. Archaic out of the box feel.remembering keybindings, and remembering all m-x commands, not knowing how to do very basic stuffI think in the early days I found it difficult to keep track of the basics – what I was doing and what was happening on-screen. Things like where point was after scrolling, which window was in focus (many themes do not make this obvious), which files I had open, whether they were modified, how to switch buffers, what modes were active, that sort of thing. I was struggling to keep my head above water. I soon got distracted by customizations and extensions. The articles and videos that recommend changing Emacs from day one. Only when I read some of the manual, exploring and experimenting with the built-in features did I find that most of those changes were unnecessary. The undo command was confusing at first. The turning point was when I discovered you could hit C-g as a no-op that allows you to redo with the next C-/. The bell sound Emacs makes when you try to do certain things was irritating and took ages to figure out how to silence it (ring-bell-function I believe). Quite discouraging to have a bell ring in your ears whenever you make a wrong move! Having used readline and vi, I was accustomed to hitting C-h to backspace a character, which caused havoc since it's a prefix key that consumes your next key presses and causes new windows and buffers to be opened unexpectedly. Similar story with C-w to delete a word, but I'd find half my buffer was deleted instead. It took a few weeks to re-train my muscle memory. For months I didn't like the backup files Emacs creates. They annoyed me and I had them disabled entirely for a while. Nowadays I like the default behaviour. The tilde backups have saved me a few headaches. Maybe you are seeing a pattern here: Emacs does not work how I initially expect (at least not without tweaking), so I try to change it. Eventually I take the time to try things "the Emacs way" and I come to appreciate the wisdom behind it – or at least that there is some coherent theory behind certain behaviours even if it's not perfect. Another hurdle for me was that the Emacs manual is not included with GNU Emacs on Debian. Turns out it doesn't meet Debian's criteria for free software, so it's in the non-free section.Lots of shortcuts to remember (but this is better now shortcuts are shown in mini-buffer with M-x), difficulty finding particular featuresKeybinding i prefere vim, elisp (first time learning Lisp), configurationBefore the system crafters YouTube channel, there wasn’t much good help on building your own configuration. Lots of conflicting/outdated advice on the internet in general around basic setup to get you started.Poor performance and hard to configuration compared to vimStick to it long enough, start small grow bigVanilla emacs was hard to grokIts usage patterns are very different from other editors. Window management seems too random/inconsistent. During the initial learning curve most people wold probably prefer a more consistent layout that resembles typical IDEs.The default key bindings are pretty crappy. Different from everything else and not necessarily better. While the documentation is good it misses in depth documentation of how things work in detail. For example, take font lock, there is some documentation on how to change it but not much about the internals of how it works.yes. mapping of Meta and Super has always been and still is a problem. Also, support for non-english keyboards can be an issue. Emacs comes with, what it seems, the worst possible default behavior when it comes to many key bindings and behavior.At the time, getting used to the keybindings. There was no such thing as evil-mode then, so I initially had to lookup key bindings. Now I'm used to them and would not want to go back.learning the keys, there were no cheat sheets available by that time and few help. I was used to a "more visual" help system as Borland Pascal had. I recall that I first started to use emacs because its support of arrows moving around the the text (as opposed to vi with hjkl).Steep learning curve without a pre-defined framework a la Doom Emacs.which-key plugin helped a lot for finding key bindings which were a bit confusing at first. Installation process is a bit complicated in order to use Doom especially on Macos. I didn't dedicate too much time to learning Elisp but so far I find it easy to understand.It seemed utterly inscrutable out of the box. I didn't know the keybindings, or how to find help. I wished I had a list of commands in something like Helm. It was also somehow sparse but too busy. It's not like a Notepad++ that just gets out of your way and let's you mess with some code. Perhaps that's because you're always confronted by the start page and concepts like buffers and windows? This kind of issue is just a matter of the user taking time, but I ended up jumping over to Spacemacs, running the tutorial and I immediately got what this was about and fell in love. I quickly discovered the limitations of Spacemacs and jumped back to Vanilla Emacs to make Emacs work better for me.No, it was too long ago (with XEmacs)...It has been a very long time, but I think getting used to the keybindings -- but back then, that was true for about every program.Key bindings (some involved many key sequences), Multilingual support (no longer an issue). The former is eventually solved by muscle memory.Coming from vim it was learning the new mnemonics for keybinds but thankfully which-key helped alotreliably setting up my keybindings and making them consistent throughout different modesCUA-mode cased a false startelisp for configuration was a definite hurdle to get started. (This was back in 1989 and I was in college without any lisp background. It's no longer an issue for me, but if it was still an issue after 33 years, that would of course mean I wasn't using it and wouldn't be in this survey dataset.)Keycords ...difficult to remember...but overcome once accustomedHelp system (info)The default keybindings take time to get used to (even though arrows, home/end/pgup/pgdn also work). And configuring Emacs (i.e. using elisp) isn't very easy for beginners.It was a quarter of a century ago, everything was more difficult on computers then.Too long ago. Reading documentation was still a thing then.Gettibg comfortable with the keybindings. and familiar with elisp. But I wouldnt have it any other way.I tried multiple times to use Emacs binds but they tended to be uncomfortable for me. Also debugging certain things can be hard once you start using packages, but asking the community for help tends to work.That is 22 years ago, I don't remember any difficulties. I start doing a PhD and my promotor introduced me to emacs because he was a fervent Emacs user.I knew about apropos but I wish I had known about describe-function and describe-variable as well.Finding keybindings for each mode.still learningKill buffers. It's so difficult to use fluently comparing a "normal" editors like Sublime Text.elisp weird variable/function differentiation and functions whichtake things that they should get as arguments from environment(with-...)Hard to learn initially, but I did in a time at which terminal usage was really common.Keybindings take time to memorize. Slow performance as more packages are addedInitial customization, although this was before package managersUnderstanding elisp syntaxEmacs lispThe default keybindings weren't very ergonomic in my opinion. Getting started configuring Emacs can be a bit challenging at first.Back in 2009-2011 the learning curve was very steep. I spent two years dabbling with a custom config every now and then until it was in a state where I could use it as my daily driver. Biggest hurdles back then was just finding/adding packages to match what I had in TextMate. A project tree file/folder sidebar, and snippets. Second was probably wrapping my head around Emacs’ keybindings.I started before emacs was solid on windows, it seemed to hard to make it work, used notgnu emacs instead. Became familiar with emacs used on lisp machines at our office, but didn't use it myself.emacs key bindings didn't come as naturally to me as EVIL modethey keybindings are weird for someone with no prior knowledge, but I've grown to love themmacOS had package permission problems, discovering features initially difficultTotally lost in terms of "this usually works like .." - one has to learn a number of keyboard moves before production speed starts to increase. Also remember as a huge turnoff that my special characters from my language were lost because I used the wrong file format.understanding the Emacs Way .. i knew there was something deep there but i wasnt sure how to get to it.When I was a novice, before I understand how most things works, I often breaks stuff and don't know how to fix. As I learned more about the working of emacs and more troubleshooting skills, I begin to really customize emacs.Lots of package installations rely on copy-paste code that you don't understand. It will be nice if projects moved to use-package and there's a documentation for common things packages want to configurethere are many and are almost the same since 20 yrs ago (when I was using emacs all the time) Bigger one probably is the difficulty to have a good configuration in the beginning this is why starter conf are so successful but those are not a solution because they include too many things .Hard to build muscle memory, feature discoverabilitySetting up the environment for working with programming languages was really hard.Uncertainty around what version to use on macOS.Code completion with cedet was not good. Clang Lsp server based implementations (eglot, lsp-mode) are a dream.I had difficulties learning all the keybinds, it took me some time to figure out how to create a new file.Not really - even though I knew nothing about programming. The tutorial was quite lengthy though, I remember having to go through it multiple times to get good at it. I still don't use the regular navigation keys, and opt for arrows instead - it works okay.I can not remember exactly, but I felt "it's not so hard to learn, compared to vim". Unlike vim, I typed "A" "B" "C" and I saw the word "ABC" on the screen.The standard GUI looks old fashioned, hard to obtain easy to understand entry level informationMemorizing shortcutsUnderstanding package loading/initialization order/hooks.Copy/cut/paste keybindings were different that Windows; terminologies like kill and yank; setting up configurations in init.el, especially copying other's elisp code into the file (looks cryptic); initially seems like it required a lot of configs to make user-friendly (e.g., like auto-complete)It's tricky to configure the language server, and I have encountered a lot of bugs when I try to set up the LSP server.*nix navigation key bindings, which I now can't live withoutThe key bindings were difficult to learn.Keybidings felt awkward. Lack of programming language support without installing packages (I wish there was an auto-package discovery), then having to figure out how to install packages.Obscure error messages for 3rd party package configuration problems. Someone who shows you the basic for your "flavor" (like spacemacs) would be nice.Overwhelming the amount of customization that is available and required, and the amount of learning needed to use emacs as an everyday editor while still being productive.Shortcuts are difficult to discover.key shortcuts were hard to rememberMostly problems with dependencies of packages/doom emacs on windowsELisp can be daunting / counter-intuitiveThe fact that all the past customize buffers stayed open(in the background) when I clicked a customize group rather than just having the current customize buffer.i don't remember, it was literally 1994unconventional keybindings, using keyboard shortcuts instead of mouse/trackpadkey binding and UIlisp and complicated internal apiLocation of help. Searching for basic functions, you find yourself deep in a hierarchy with little idea how to find your way.Hard to get started without a starter kit.The paradigm shift that meant understanding the basic concepts. I spent about six months not knowing what to do with it once installed.Elisp being somewhat awkwardobtuse controls and "lack of documentation". I understand the tutorial\docs exist and are phenomenal, but most people want to get straight to editing code and that's hard and there's a well known initial cliff.I tried to use Spacemacs (which was the “best” distribution at the time) to ease migration from Vim, but it was too big and complicated (and slow) so I ended up going back to Vim for a while. I eventually used a config I found on some blog when I returned, slowly adding to it over time, until I eventually decided to redo my config from scratch. In hindsight, it would have been better IMO to begin with default Emacs.The default keybinds of emacs are very different to what I'm used to. That was and still is a difficulty I'm facing.Ctrl-ZHaving sane defaults, hangs with long-running tasks, lack of tutorials that didn't require a LOT of previous knowledge or didn't make sense outside of someone's particular setup, having sane setups for programming in common languagesI don't recall any specific major roadblocks, more like papercuts. Learning Emacs is hard because almost everything about it is at least a little bit weird or broken.I am currently learning emacs, most difficulties come from debugging stuff and setting up the vue lsp (Volar) was funkyELisp and default keybind.unconventional keybinds, configuration guides tend to be opinionated and specific to particular setupsThe First times (20 years ago) weird keybindings, and a distinct way to interact with buffers/windows. I like it as it is thoughNothing about it made sense in 1989.Remembering hotkeys with long sequencesMemorizing keybindings. Configuring packages.Not really, just a process of discovering features and capabilities/packages I didn't previously know about.emacs chords and emacs terminology (frames, find-file, buffers, etc)The documentation for Emacs Lisp doesn't talk about what a function returns?Configuration is something tough.None, the introductory screen and documentation are reasonable.Advice, configs, etc. found online are frequently not for your version or flavor of emacs - googling for a quick answer doesn't work well.The biggest issue is a the wrong / outdated / alien default set. Overall, it was completely unorthodox and if it not were for the fact that I had lots of time and energy to put into it, and liked lisp (I was at university at the time), I'd never would have stuck with it. In my opinion there should be a new-world set of defaults and a one-liner way to get back to legacy ones. At one point in time it just makes sense to adapt to the world standard so 10 years after that, all the quirkiness is not expected by most of the userbase. The second one is the disregard for working correctly / kind-of-natively under Windows. It shows disrespect for the situation of users that are forced to use Windows at work.When I got started I immediately installed many packages (e.g. evil-mode), which needlessly complicated my learning journey.Remembering the default key bindings and, in particular, switching from CUA so that C-c, C-x, and C-v behaved as I was used to, to the default bindings in Emacs and using CUA bindings in other apps.There is not a central location to browse different configurations/ways of using Emacs. The spacemacs/doom emacs documentation almost fills this hole, but they are opinionated and do not show the full breadth of available usage patterns.Learning what was available, learning how to use packages, keybindings1. Elisp 2. Hard to find sane defaults 3. Any modern book to learn most of it and keep it as referenceInitial configurationthe keybindings seemed random to me at first; they didn't seem mnemonicYes. I recall ALL the difficulties. Mainly created by self (I turned of menus from start - should have left them on for first 3 months)I mean, I’m six years in and still feel like I barely know anything. When I started, the problems were mostly on my end — trying to over-build my own configuration to do everything possible, rather than starting from base Emacs and slowly building up packages and functions and customizations as I hit pain points.Very, very steep learning curve. I still have not fully mastered Emacs. Even though I'm a programmer, I don't program much in Emacs. Setting up a new language environment is simply too cumbersome.A rumor that emacs is hard made me hesitate to start it.I remember when I first started looking at emacs about how different it was compared to other text editors. Everything was non standard(compared to what I was used to) and it looked to be missing a lot of features(at first glance). The initial experience out of the box was not great. I did not like the look of the editor(visually) I did not know how do a search, search and replace, switch between files. I did not understand this whole concept of what a buffer was. I was used to files opening in tabs. I found all of the documentation difficult to understand a lot of it involved (weird looking lisp), copying and pasting bits of code without fulling understanding what I was doing. Simple things like getting syntax highlighting where difficult and every aspect of emacs was so different to all of the other editors out there I spent ages reading documentation which lead me down more and more rabbit holes. It wasn't till I started using prebuilt distributions like spacemacs that I came to appreciate just how amazing emacs is. It was also around this time I started learning lisp and finally understood what I was copying and pasting to the point I did not have to do this as I could write my own specific to what I do that emacs become so useful. A few things that I think would really help beginners is to have some kinda of official demo video of some of the killer features (i.e like wgrep, keyboard macros, avy jump, undo tree etc). Beginners don't need to understand how to do this just that these things are possible in the editor. To give them motivation to go through the pain of learning emacs. The final thing I wish I had known earlier was a little bit of elisp. Not enough to be able to program any packages or mode but just enough to be able to understand the code that I was copying so as I could tweak them. Even realizing that (next-line) was executing a function called next line was so powerful as I could start chaining these up (next-line (next-line) (next-line))..Weird alt placement on Mac keyboardPretty much everything about Emacs is hard to learn. I've been using it for nearly 30 years and barely know how to do anything beyond the most basic operations. That said, that's partly because I don't use Emacs *exclusively*. I do most of my coding in an IDE (Eclipse) and usually use Emacs for "quick and dirty" terminal based edits.Coming from a workflow rooted in the command line, Tmux, and Vim, I could not figure out how to work the built-in Emacs tools (Dired, Shell-mode, Async Shell Command, Compilation-mode) into my own daily work flow, or how to abandon my command-line-centric workflow and begin thinking from an Emacs-centric workflow.I couldn't figure out how to use tabs instead of spaces. The appropriate option for this seems to act as if tabs were just a fixed number of spaces.It was one big difficulty, coming from default microsoft driven world, it seems like you have to learn how to use a computer.It took some time to wrap my head around handling multiple buffers, I was used to tabs etc. so I was confused about where they went and how to find them again.Elisp , as I don't know it yetEmacs pinkie, solved by switching caps and control keyscomplexity of simple tasks, key-combinationsEmacs key bindings seem peculiar at first.Common features quickly find their way into muscle memory. But sometimes features are easy to forget how to invoke/use and can be annoying to refind/discover.Not knowing what plugin or configuration is causing an effect on the editor.1. Learning key-cord 2. Configure Emacs 3. Understand how Emacs loads and workIt was difficult to know about/use many powerful features since there are few menu bar options and fancy buttons in the user's face, as opposed to many editors which make their features clear to the user with bloated, nice-looking interfaces.Hard to remember keybindings, hard to remember how various modes work after not using them for a while.I got completely stuck numerous times because I didn't know key bindings, and things I couldn't find simple ways to do certain things.Steep learning curve due to complicated hotkey chords Vanilla config too lacklustre and not very beginner-friendlyThe default keybindings suck. Compared to VIM the help is all over the place (in vim it's just :help ) in Emacs it is C-h (f|v|i|etc.) depending on the type of thing you want help with. In vim to change a setting it's always just :set = In emacs it depends if it's setq, setq-default, ( 1) depending on whether it's a variable, buffer-local-variable, or modeYes, key-bindings were unfamiliar, took me very long to really start using Emacs key-bindings. Selecting text was unfamiliar. Lisp was a very unfamiliar paradigm, still don't feel competent in it.Understanding elisp and how to copy paste something working together.Initial configuration requires programming knowledgeNon "standard" bindings for very common things live Save, Quit, Copy, Paste.start w/ cheat sheetFinding and memorizing keybindingsNon-standard keybinds, old out of usage terminology (i.e. frames)Figuring out which parts of Emacs are up-to-date and which parts are effectively deprecated.emacs lisp - took my time to understand syntax and language featuresThe main difficulty is that if the program crashes, I lose all my sessions.Default settings and keybinding are arcaneComing from vim it was a challenge but not huge. I'm still learning the default keybindingskeyboard bindings over dial-up can be confusingThe way it references keys or it's chordal nature. vim was easier to get into- the keybindings: I didn't know how to open a file, close a window (sorry, a frame). So sad nothing was explained on first page - the language: what is a frame? what is a window?I declared init bankruptcy twice. The second time was with spacemacs, and I recall the layer system getting in the way of what I was trying to do (now I run vanilla + my own created hell, rather than someone else's)Configuring for certains packages/modes was (and still sometimes is) a challengediscovery of keybinds. I have a folder called foobar and want to create a folder (using ivy). type "foo" then hit C-M-j.Oddly, the thing I remember as the most disorienting was leaving the Vim workflow of "invoke editor, edit, quit editor" for the Emacs "leave the editor running all the time" workflow.I started with evil-mode but did not like the amount of configuration needed. I've been re-learning using the defaults for the past few months. I find the "info" system cumbersome to use although I have not internalized the document structure which is probably where the issue is coming from.Default settings were abysmal, but in the last 2 decades things have improved. We could still do better with a great onboarding experience.It doesn’t use Joe key bindingsLearning Emacs presents the same problem as learning any significant GNU project (Emacs/Guix) - one will need to read most (if not all) of the manual (or code) to attain an actual understandinglearning the keybindingsCrappy C-o to switch buffers. Very inefficient instead of C-. A bad design choice I understand, but it presents a massive barrier. Much easier visual configurations. A few 2-split and 3 splits should help new users File navigation until you simply switch on Neotree or use speedbar.Starting out was a little rough. I think I tried Doom, then Spacemacs, then finally just did vanilla Emacs and did my config myself. Getting indents correct for C in Doom was frustrating because I didn't know elisp at the time and their config structure was kind of weird.I dont code, so everything ;)How different it is from normal editors.weird keybindings, lengthy manual and lots of options and packages. no step by step tour of major things in emacs apart from basic usage.- Emacs lisp is not Common Lisp or Clojure - Configuration reproductivity - Too much config needed for Vanilla Emacs to goFinding what the current 'best' packages are. Navigating the huge amount of configuration.Keybindings that were unfamiliarI was not diciplined enough to sit through the tutorial or read the manual. Part of the reason was that Debian did not distribute the Emacs manual in Emacs, so I had to read up on stuff online, including blogs written by people who in retrospect did not really know much about Emacs.Key mapping for Backspace, Delete, etc, in the MS-DOS terminal. Today, mapping Alt-x in xterm is still an issue.Trouble finding which user option does whatever it is I'm looking for.Big learning curve.Complex key bindingsToo long ago to remember!I still don't feel like I "know" emacs. I know enough to use what I need, but sometimes integrating something new toy workflow takes years.building the muscle memory for the keybindings I was using. Also learning how to debug when I ran into errors (still struggle with this ocassionally, but getting better)one small mistake and everything slows downs badly, or crashes out. debugging is very hard.hooks, modeLearning to debug elisp, mostly.Vanilla key bindings are not intuitive (Ctrl + G instead of ESC to quit things?) and the completion for M-x doesn't help. Vertico is a must in my opinion.many many difficulties :-). - understanding elisp (lisp in general and the quirkiness specific to elisp) - not getting things out of the box - understaning errors - emacs breakdown ( with spacemacs and then doom) my config would just not loadThe biggest hurdle was it can be somewhat difficult to find how to configure certain behaviors. The built-in documentation is extremely helpful but when starting out I could never remember how to find it.After an initial learning phase using the emacs tutorial, I felt a bit stuck as there was no obvious "next step" to follow. I could use basic text-editing features, but the whole extensibility and customization thing was completely out of reach. For some years, configuring emacs was a matter of googling "emacs + current programming language" and haphazardly copy-pasting whatever came out into my init.el. Discovering doom emacs made a huge difference for me, for 3 reasons : - it provides a structured framework for configuration - this framework has extensive AND organized documentation - it has good discoverability by default, e.g. with which-key.I don't recallEmacs was (and it some degree still is) horrible out of the box. I built my own config with and without Org over the years, used use-package and avoided it, spent years with Spacemacs, dropped it, picked up Doom, and heavily modified aspects. It takes so much work to build your own dev environment but can pay off, a bit like building your own house.E-Lisp was incredibly difficult to learn, especially with Doom Emacs - copy pasting from the internet wouldn’t always work and annoyed me a lot. Additonally, there were a little too many extensions to choose when I tried to configure regular GNU/EmacsYes, the internet was young and you couldn't just "Google" something.The UI is different from the established standards, the learning curve is steep.You can go down a hole where you keep installing packages and things start breaking.Understanding elisp, all the keybindings and how to install and configure packages.Starting out with Emacs I didn't really understand the concept of prefix arguments. I didn't know how to leverage them, which limited the utility of many built-in features in my initial Emacs experience.Creating your own config is a bit of a rabbit hole to keep it performing well. That's why so many starter kits exist. Learning emacs was OK once I installed evil and a good autocompletion such as ivy (now on vertico)I had to learn bunch of commands and keybindings. window/frame management is a PITA.pasting from clipboardIt would be nice if there were some clear way of learning Elisp so one could better grasp how to extend package functionality in packages such as org-mode (e.g. I want to output MathML on my HTML docs, or I'd like to ensure accessibility properties for some elements, or integration with gettext so I can produce several versions of a single doc).most of the time, authors of packages (this applies to emacs doc as well) only thinks about advanced usersDid not understand how to cut and paste, I switched to vim to cut lines, and then back to emacs to edit...Documentation is mostly complete but the learning curve is somewhat steap, when you don't know the terminology.The lack of glossary. Buffer. Frame. File...Default key chords, solved by using the Doom Emacs framework as a Vim userBasic dired and using Emacs without ivy (or similar) really put me off. More of the documentation should focus on minimizing bad first experiences. Mastering Emacs' docs on keybinding is basically a must read,the official docs don't even come close.Finding resources to make things the emacs wayKinda hard to learn Emacs key shortcuts, so I went with VIM which I knew from beforethe workflow not obvius, but you get that with brioToo many packages that can do the sameLearning how to use the docs mostlyWhen I opened a pure emacs, I didn't know how to get started until I used spacemacs.Overwhelming amount to learn before becoming productive in emacs: - The emacs and elisp, org mode etc documentation is thorough, but it was too much for me to read at once and it was difficult to decide what would be helpful for me to read to achieve what I wanted - I wanted to install various plugins to reach parity with my previous vim setup, but I struggled with installing, customizing and debugging them due to limited understanding of elispGetting used to the important keybinds such as M-x, C-c etc.Broken packages and things not working out of the box at all. The introspecting features of emacs are not clearly explain as part of tutorials Lack of proper rendering, just using text alone is boring and wack in 2022Basic navigation and editing. I should have just read the tutorial.Learning the different key strokes was hard. I focussed on just the vanilla version to configure, as sapcemacs and doom added an extra layer of unwanted complexity to it. After that I had a hard time getting my mind to work around org and orgroam.ELisp - seriously needs an update. Having map/list/set literals, ala Clojure would be fantastic. Also something similar to spec, just so I could look at a deeply nested alist and actually know what each part is for!Emacs felt very large at first. Way moreso than vim. Having so many places where new users have to change default behaviour to mend papercuts is a detriment. Some examples: - Not having a simple binding for switching windows (C-o vs C-x o). Every bit of extra effort to do something users take for granted as 'simple' in other programs is abrasive for new users. - Having very useful features locked behind elisp (winner-mode, (f)ido-mode). winner-mode in particular is a 'wow' moment when the user finally finds it. - Polluting all directories with backup / lock / autosave files. backups should be kept in the emacs directory or cache by default. I think that much should be uncontroversial. - Mouse scrolling not working like any other program I have ever used. It was unusable out-of-the-box. Not sure if this has been changed. - Customize interface polluting init.el. For a new user who is not used to looking at elisp especially, it is a very nice change to have custom.el to contain elisp from customize interfaces. - Which-key or similar should be a built-in. The huge amount of keybindings is a lot at first until you learn to use the help system to navigate them. - Depending too much on other people's elisp through package readmes, emacswiki, and especially emacs distributions. It takes an intermediate emacs user to know that the power of emacs is already there in the defaults. To make that more discoverable means the simple addition of a completion package (ido/vertico) and a properly set-up package management system (use-package). Having to figure out first the 'right' way to manage packages for a new user, frankly, sucks. Installing packages through list-packages just feels wrong. It's fragile and makes your configuration hard to move between computers and harder to fix when something goes wrong. custom-set-variable seems like the wrong way to configure and install packages. - trying to get emacs to behave like a true IDE was a mistake I made in my first months. I had to have someone explain that to me. - A difficulty I still have is finding a good resource for elisp. A terse textbook in the style of pragmatic programmer textbooks would be ideal. This was a lot longer but there's a 400 char limitlong time agoI mean its still really difficult to understand how Emacs fits together, the multiplicity of packages that Doom uses (ive tried to roll my own but it was too painstaking to get it working to the level of Doom) means that it functions as an amazing editor but also means its hard to grasp how everything hangs together.Emacs has changed a lot in the last 20 years and I don't think my difficulties are relevant any more.Lisp.Vim bindings are obviously a hack glued on emacsLearning the builtin elisp functions. Most are inconsistently and confusingly named, so it was hard to search directly for a function that did what I wanted. I end up having to Google "emacs X" every time rather than committing the esoteric names to memory.Hotkey menus not builtinUsed to modal editing, and places where evil-mode stopped working were hard before I got some proficiency with Emac's default keybindings. Which-key helped a lot with all of the prefix- stuff.It was very difficult at the beginning to get things done. Navigation between buffers for example, project management was extremely frustrating. Also I struggled a lot to configure Emacs, I couldn't get LSP working. I never was exposed to LISP languages, so I didn't understand what happened when I copied configuration. The lack of integration with build tools was also annoying, for example in many IDE you have a function to automatically configure cmake/meson/[build system] and compile, and I ended up writing my own package to do it. The window management when an interpreter is open was also unsettling, it was hard to keep it while changing files frequently. It turns out that many of my issues were already fixed by Emacs, but I didn't know it at the time. Not because of the lack of documentation, but because the quantity of tools is so overwhelming that I couldn't know they exist.nobody around me uses itLearning enough key bindings to be effective and efficient.Lots of difficulty knowing which commands/keybindings were "important". I made flash cards specifically for basic navigation and org-mode, and over time learned which ones I'd end up using daily. Its the curse of exposing every possible options as a a command or key-binding -- its hard for beginners to know whether the actually every need " C-u foo M-bar C-x C-b" at first glance.I never figured out what it was for, why should I use it etc. I only started using it after I read somewhere about mmm-mode which solved a problem I had at the time. I then forced myself to go through the built-in tutorial and eventually got used to it, but I never explored beyond basic use until years later. Probably because I never heard of lisp before and any occasional under-the-hood peek was confusing.It took a little while to learn. If you want to learn everything it will take a long time and could be overwhelming and probably not practical for most peoplemoving from vim to emacs keybindings, I didn't know about evil, and something like Doom or Spacemacs weren't a thing back thenRemember shortcutsA variety of documentation from different starter kits (DOOM / Spacemacs) makes it pretty confusing when starting out.remembering basic keystrokesFinding and installing packages was way more complicated, but there have been a lot of improvements. I think it'd be easier now.The keybinding and keys needed to perform basic functions are not intuitive at all (using text version). The GUI makes this easier.Learning curve adjusting to key bindings and using M-x functionality paradigm.Elisp is still the biggest hurdle for me. Luckily it's pretty rare that I have to drop down to Elisp code and using a distro like Doom means there are very opinionated ways to do things and lots of examples in the source code for that project to follow. Some other issues I recall from my early days: understanding the difference between major and minor modes, pre-vterm terminals, modern web tooling is a little tricky (still!) with flycheck.My primary difficulty in initially learning Emacs has been understanding how the configurations should be structured. I started on Vanilla Emacs and struggled greatly. I moved to Doom Emacs within a month and explored a more fleshed out Emacs with many of the packages and settings I strove for already there. I had trouble understanding exactly where all of the configurations controlling emacs are located, which takes precedent, which loads first, where things should go in my config, etc., especially since I used vanilla Emacs so briefly before starting with the Doom Emacs package.Lacking of books to learn eMacs beyond “tutorial”When I first started, the "Emacs renaissance" was just getting in to full swing, so there were fewer up to date resources online. Recent personalities have been a big help in this regard -- Sacha Chua, System Crafters, Prot, etc.Figuring out all the keyboard shortcuts vs. Just falling back to M-x.No, I started using it when learning Scheme and Lisp.Coming from (Vim and) Sublime Text, the C and M keybindings took me some time, and Emacs Lisp was quite different from what I knew.It definitely slowed down my actual text editing compared to vim, but I found it hard to learn emacs while using evil bindings. So I had to learn with the default keyboard setup. Then a few years later I added evil mode again.Getting comfortable with all the different manualsEmacs is a different culture (keybindings, terms, etc.) from Windows/Mac/Linux. Took a while to realize that this needs embracing. That means things are not familiar (often confused with being unintuitive). The windows setup is extremely difficult to be productive in. Many assumptions made by packages are not true on windows diminishing the Emacs usefulness.Yes, the bindings are rough and nativating the built-in (or web) docs is not very user-friendlynames of interactive functions that i neededVery steep learning curve, still isLearning keybindings, figuring out which packages should be used and how they should be configured, finding where internal variables are for setting certain options.The extensibility can be daunting at the beginning and the defaults are too different to what most people are used to.How to search for help and read documentation about variables, functions, shortcuts, etc.^z makes the GUI version hang - it's only really appropriate in CLI versionThe amount of "flavours" and variations (every emacs installation with its specific combination of extensions and config is a unique snowflake) made it difficult to search for documentation, and/or know if something I was reading was applicable to *my* emacs or not, or how to specifically do something on it.not knowing where to find the features I wanted, outside of VIM keybindings (reformat code, go to a symbol definition, etc). Spacemacs and later, DOOM emacs helped enormously with their mnemonic 'space' menus.Keybinds, default GUI, Windows support, daemon modedrop-down search of manuals (info)Keyboard driven usage is hard to wrap your head around when coming from a mouse centric paradigmThere was too much stuff!!!I did not want to learn all those keyboard commands so I gravitated to the gui mode for a long time.memorizing keyboard combinations, understanding buffer behavior and managememtthe keybindings are hard to pick up at firsrLearning keyboard shortcuts (as evil does not entirely map to neovim's default keybindings); opting into features useful for me (e.g. nativecomp & native GTK)Key bindings were hard to remember & get used toI learned it very slowly, as I needed parts. I still have problems with emacs regexLack of feedback by default on what key presses were doing.Struggles with installing and configuring.Steep learning curve. difficult setupeasy settings for notepad++ options like autosave, tabs, recent files and completion-at-pointYes! Keyboard shortcuts, overall usage.Even with a starting configuration like doom, Elisp adds a high barrier to entry. There is also not a version of the full tutorial written for anything but vanilla emacsUndo system were complicatedTyping is too sluggishStill learning, probably the hardest piece of software I've found worth learning. At the beginning I knew neither Elisp nor Emacs as a platform. I'd learn a little elisp and not understand how to apply it to customize things my way. There is no standard way to install packages, and at the beginning I needed step by step instructions. If I was installing packages in a way that wasn't covered in the instructions it was sometimes difficult to figure out how to respond. There are so many interacting parts in Emacs. Until you get to know Emacs (which I'm still doing) it's difficult to tell which part needs to be edited, and how that edit will interact with other parts.The use of the elispUnderstanding LispSlow with LSP Hard to figure out how to configure Hard to understand keybindings Hard to debug random issues.Elisp, to understood the whole ecosystem, buffers, window, modes, ...Key bindings, and learning a few macros.the tutorial intro is too long and focuses on movement in text too early. window management should be explained earlier.Figuring out keybindings was my first hurdle. Learning about a feature or a built-in command and forgetting that they exist the next day has been an ongoing thing for me, but in time the features that I find most useful get integrated to my workflow.Finding out what I should learn next. Spent a lot of time reading blog posts and talking to people before I found a set up that I was comfortable with.Getting it to work. It took me days to just having it open and close (on MacOS). Sorry I can't recall anything specific, it was a year ago. To this day (now on Ubuntu) I sometimes find myself not being able to do basic things and I personally can't easily navigate documentation, I resorted a couple times to asking on Reddit.1) Learning the keybindings. 2) Learning lisp in order to do any customizing or install / configure packages. 3) Finding relevant online documentation that is current.The lack of knowledge when choosing: Everyone in the community is using different solutions for a same thing, some people use the builtin package manager, some people use straight.el, some people use use-package.el, some people use ido, some people use ivy/helm, some use vertical, etc. It's extremely overwhelming to build up one of their own configurations when they don't know at all what would work for themselves.poor knowledge of lispDidn't understand line break mechanism when writing LaTeXI had to have other expirienced person to help me get through first weeks of learningThe sheer learning curve, there being so much of everythingEven though I use default keybindings because that's where I started, they aren't friendly.learn a new language to configure a environmentKey bindings Wege very weird at first coming from a Windows background.Out of the box, it looks like 1980's.Lisp looks dauntingNone, the built-in help was on point and taught me everything I needed to know.Getting started for configuration. I was using Doom Emacs and while it can serve as an example, navigating around the code of the configuration (seeing definitions, getting the location of the keyword, etc.) serves as the initial challenge. I simply didn't know Emacs has extensive ways of getting and seeing documentation. Nowadays, the challenge is more on navigating the API to serve my own purposes. ;pPackage installment.None really. Some terminology took a bit of time to adjust to, but nothing critical.Key binds are very obscure but quick when learnedNot knowing where to start. Unused to the Emacs learning curve, and thus unable to "just use it" at first. Took me a few tries.Things like "sequential" key bindings (e.g. C-x C-c)were initially a bit foreign but got used to them quickly.Lack of unique configuration framework. Tweaking a configuration take time to get it right.Too many commands, too many keys to remember.The keybindings, understanding elisp and understanding how emacs worked.The keybindings took a while to learn and elisp was different enough from clojure that it took time to understand to be able to extend emacs.- unstable packages (as in updating them breaks them) - decision fatigue (how to choose between packages doing the same thing) - no "just works" experience when working on a software project (compared to a full blown IDE that automatically parses a CMakefile, provides a view of the project and let's you just to definition and see usages of a function/variable easily)User interface is highly alien and the tutorial is not sufficient to scare new user. The default are terribly out of sync with the times.Learn tips and trickIt took me a while to bind Caps Lock to Control. Disconnected TRAMP sessions used to freeze Emacs for me. I think I had to configure the kill/yank system to work properly with system clipboards.Getting to a sane productive configuration. Without things like which-key, vertico/ivy/helm, and marginalia, it's very difficult to learn how to use Emacs. I feel Emacs' biggest strength is how easy it is to search for commands/variables and see documentation, but it's not clear how to do that as a beginner. Without something like Doom, I wouldn't have understood what makes Emacs great. Even if I think the frameworks are a bit heavy at times, it's easier to customize downwards than upwards.Default keybindings: Took several times (several months apart) until I managed to get through the tutorial.Without doom, I found emacs to be incomprehensible and close to unusable.sudo elevation, which I still haven't nailed down....Configuration, discoverability, remembering key bindingsFiguring out configurationMainly around documentation, i spent many hours traversing and understanding different ways of accomplishing the task of getting packages until i found use-package. Incompatible packages, mostly due to my own lack of understanding how hooks and emacs internals work. E.g. getting code completions to work in lsp-mode.Understanding how it all fits together and which functionality to actually replace, vs use built-in emacs functions.I am still in the process of getting used to the keybindings, and learning all of the configuration settings I want to use.I tried to learn Emacs and Gnus together which made both much harder!When I was initially learning Emacs, what I wanted to resolve were: 1. How to configure my own setting in Emacs Lisp? How to well structure those configurations? How to bind key with some function or feature? 2.Keybindings, but this difficulty is also emacs strength. Like playing piano (I guess), you cannot be proficient without practice.Elisp was scary, but it was worth it, now I love it. Coming from Vim, Emacs bindings were weird, but not that weird (similar to a shell). I've never learned it and it feels like I cheated. Without DOOM or SPACEmacs i would never tried Emacs, So i guess a more configured out-of-the-box emacs would have been nice ? Like, if config file were not found, ask if user wants vanilla emacs or a pre-configured experience, ask user habit and generate a few config files) But don't let me look at Elisp unless i want to hack it (not everybody is interested at first). Debugging Emacs (start up or functions) feels weird, it not modern at all.emacs is not an editor but rather a runtime a bit similar to electron. to understand you load "modes" and everything is brought to life by functions triggered by hooks is actually simple, but hard to figure out.Moving from modal editing to emacs keybinding, also understanding elispMemorizing the key bindingsDifficulty selecting from all the huge numbers of different packages (still a challenge), figuring out why some configuration isn't working (still often a huge challenge)Elisp learning, keybinding.Missing documentación translatationVery hard to debug java codeThe docs are horrible, the terminology is obsolete (meta vs alt, frame vs window, etc.) compared to modern UI paradigms, and emacs itself is discouraging because the default theme looks like abandonware so you worry you're wasting your time.At first I didn't even know what emacs is and how it could benefit me and my workflow. The tutorials didn't explain the possibilities well. But I am so happy that i stuck with it.Keybindings are a mess. No consistency. Too many things to learn at once. Bad defaults.Not being able to find commands or even knowing their names (e.g. "visit file" instead of "load"; "yank").Initially I didnt know of configs like doom emacs. Its very different compared to gui based configuration.The default key bindings are very poor. Using C-x o just to switch windows was especially off-putting.The very different jargon, the various keybindings and commands related to each major and minor-mode.Practical tutorials that would use vanilla Emacs rather than a bloated configuration like Spacemacs.I thought it was crap because pressing ”home” took me to the beginning of the file, not the beginning of the line.Everything is different compared to earlier editors I had used. All shortcuts are differentClassic Emacs hotkey scheme was extremely unintuitive to me at first, and also hard to use on a standard PC keyboard until I swapped Caps Lock and Ctrl.The tutorial was kind of a slog to get through. package.el is kind of annoying to interact with.Only that there was always more to learn.Hard to get into muscle memory, very steep learning curve, but after some perseverance, one day it clickedI have never learned Elisp which means I can’t make packages.The learning curve. I started with Vanilla Emacs and failed to learn the keybindings. Then i used spacemacs, witch is buggy and need a long time to start. Then i changed to doomemacs and i started to create my own keybindings (SPC g s -> magit status). I am missing a easy to remember keybinding mnemonic keybinding set.Trying to get GNUS to do anything worthwhile was extremely painful.managing config files (pre package manager)Default key bindings; unaware of other programs and conventions that make for a more uniform experience (Emacs didn't have a package manager, then, so that may've contributed).No, it;s too long ago. However, I'm still learning and find that the proliferation of packages which perform a similar task can be confusing. Also, since Emacs has been around so long, it is sometimes not clear whether information about it on the internet is obsolete or not.Region / kill-ring / yank which is very different from usual copy-paste, but it improved in recent Emacs, and it's powerful once you're used to it.Emacs Lisp's macro. It gives me hard time to understand the syntaxing.It was a very long time ago, I honestly cannot remember.its hard to realy switch, but when done super efficientConcepts of frame, window, bufferDiscoverability of configuration, missing refactoring and code-completion features (or rather harder to configure them initially). Development of your own workflows is the primary strength but the fact that some level of development is necessary of "basic" flows is a hindranceThe sheer number of keybindings was initially intimidating, but as I used it more I realised which I needed to know and which I didn’t. It was also difficult to use commands such as M-x or switch-to-buffer before I discovered completion packages.Combo Key chords. By now they are third nature (well past 2nd).I still barely know how it works except for the things I use.Steep leading curveLearning the keybindings, learning how to configure packages I was interested in- Understanding differences between Aquamacs, sytem emacs on OSX, "Emacs for OSX", etc. Just the general version confusingness, and where to store customizations. I eventually switched to compiling my own, and life was much easier in the long run.The keystrokes seemed very cumbersome.The biggest two hurdles I faced(which I still face) are needing to keep several sets of keybindings memorized. (emacs, CUI and VIM are all important tools, and the context switch is frustrating) Poor documentation of community packages, so many people don't write info files but just link to their github page for the package.I put a lot of pressure on myself to understand things as deeply as the manuals went. That caused me to become demotivated frequently, so it took a long time to finally get around to learning most of what I wanted to learn.Moving keys, like C-p, C-n, C-f, C-bThe docs contain a lot of information. As a novice, it was hard to understand what to learn first, and skimming through was almost undoable. For if I skimmed, then I'd find myself puzzled. I spent hours and hours at cost of my free time. Keybindings kept falling out my head. Things went really slow until I tried Centaur Emacs, then exploring new features became a breeze. Vanilla Emacs is unsane for new users.The way keybindings are set and overriden was initially confusing coming from Vim/Neovim where I had fairly extensively modified the "normal mode" keybindings.Discovering the available features was far from obvious. I only really started exploring things once a colleague recommended I install helm-mode, and it really feels like it (or a similar functionality) should be part of the vanilla Emacs experience. Being able to just do M-x whitespace (or C-h f whitespace) and be shown all whitespace-related functions is a blessing when you don't know what function you're looking for.Somewhat hard forward, backward navigation and a strange keybinding for start of buffer end of buffer (M-<) that I still can't get used to. Lack of interesting Elisp learning resources, since the GNU docs looks dated and somewhat techy (somethin like Brave Clojure is sorerly needed for Elisp).Yes. Remembering control keybindings for things. Managing UI/buffers/frames seemed difficult. Differing concepts like how copy/paste works vs. how kill stack works. Switching to doom emacs eased setting up sanity for some of these issues.Mostly knowing the keybindings and knowing the way aroundHard to learn the key-bindings, the jargon and to set it upDired shortcuts due to lazinessKeystrokes. I still don't use most of the extended text-motion or deletion commands, as I can never remember them.key bindings, prefer vim settingsNot a lot of learning materials outside of System Crafters youtube page that I saw. Takes a long time figure out how to use elisp, in my experience.I had troubles learning keyboard shortcut, and generally how the editor is supposed to be used. I was not a developer at this time. Learning was not difficult thanks to the documentation (and youtube videos made by passionate people). Issues encountered using various third packages and their debugging were the difficult part for me.There were stability issues with no initial understanding of how to debug or fix them. The first time I tried emacs ~4 years before using it, the keybindings and classic default UI deterred me. The keybindings only became comfortable after rebinding some keys on the keyboard.The keybinds can be harsh in the beginningToo much information on the web but much not usable or applicable. Quite hard to to learn.The motivation to RTFMCan't remember -- it was 1983! :-)Learning key bindings, but that was 40 years ago ;)I took a little time to get used to the key bindings system.lack of in-context help (e.g. it would be nice to have a menu showing the actions available in the current mode)Prior to native comp, Emacs was kind of painful to use on large projects.This was many years ago, but I remember the first time I tried I gave up because I did not have a Meta key. The second time I gave up because of the default key bindings. The third time I gave up because of accumulating friction - "Customize Emacs" menu did not seem to save my preferences (what is "save options" ??), a general misunderstanding on my part of Window vs Frame, a frustration over modal text input, and an apparently burdensome copy/paste process.TECO was difficult to learn so I regrettably never tried.No, too long agoThe keybindings were initially hard. Installing Helm and using M-x to find functions by name and seeing their keybindings helped me a lot. Also knowing C-h k is great for seeing what keybindings actually do.I made it so...noConfiguring the system was difficult. It took several attempts before it could be considered reasonably bug-freeInitially the amount of keyboard shortcuts overwhelmed me.A few platform and version specific issues with macOS needing exec-from-path and the Terminal.app's using of option/alt for unicode characters instead of as meta.Usual limitations you get in open source: a large amount of options, which to be understood require experience, specific tech knowledge, and familiarity with jargon. With time you grok them all but it's a journeyThe weird emacs key bindings.It was a bit different concept from enduser softwares, learning lisp and understanding emacs as a software platform (not just an editor) made things easy for me.probably the keybindings, and to figuring out how to copy (kill) paste (yank)Nope, the quality of the info manual was decisive in my will to learn more about Emacs internals.Mark and kill.When installing spacemacs it feels like there is always at least one package from elpa broken at any point in time.1. Learning key bindings (fighting old muscle memory): I used joe before, solely because it had WordStar key bindings that had been ingrained in my fingers since middle school. As a new Emacs user, I didn't start out using anything like helm or Ivy (I use helm now), which would have eased the learning curve. 2. Learning how to customize Emacs as someone who had never worked with a Lisp before. I struggled by cutting-and-pasting code snippets without really knowing how they worked, or how to use Emacs' built in help and introspection functions.Defaults did not include features that most people would turn on - back in the day it was fontification, these days it's things like auto completionI had to read Emacs Manual from the beginning to the end.It's been a long, long time now, but I think it took me a long time to absorb the fundamental Emacs concepts that mirror other platforms. What is the 'point'? What is 'mark'? What is a 'region'? 'Frame' vs. 'buffer'?Know how to do things and configuring the editor for my needsHorrible support for complex (multi root with multiple node_modules) Javascript projects. I still cannot get Facebook Flow (typechecking for Javascript) configured after 3 years of trying it periodically. No support for functioning Java projects with Gradle (that would include Emacs comprehending the overall project structure to do code refactoring). I use tramp mode a lot, and editing files requiring a sudo privilege is not 'easy' to grock. I have to start tramp mode with (pipe sudo). It should be more user friendly. Also I want to use emacs with eshell + tramp mode instead of TMUX, but creating a new shell requires specialized commands, In tmux it is easier. I think Emacs needs to figure out how to set 'Use-case' specific defaults where multiple package are configured for a particular use case. Eg TMUX -replacement use case (eshell + tramp). JavaScript development with Flow Java development with Gradle Java development on android and so on. These are obvious use cases, but it is really difficult to configure individual packages.Apart from the usual suspects of switching to a new editor (keybinds, where things or functions are, how to interface with other utilities), something I struggled with (and still sometimes struggle with now!) is the framebuffer-window modelI was in college and didn't have much experience with coding in general. I had trouble with keybindings, screen layout, packages (at the time), core concepts (buffers, etc).I initially started with spacemacs and it was confusing trying to understand the differences between setq, setq-default, set-local, customize-set-variable, customize.el's interface, and the way spacemacs handled all thisKeybindings scheme was really confusing compared to CUA. I also missed tabs until I learned to switch between buffers.idiosyncrasies such as buffer system and keybind system, broken packagesIt was (and still is to a point) unclear what are variables or toggles, and how they are configured in the config file/session/buffer.I kept searching for advice with terminology used in other editors. For example copy and paste. Sometimes it would take a while to find these simple things because the docs use different terms like kill and yank. The docs are also a bit cryptic for a beginner. I would find stuff like `C-x C-s`, `M-x` and `S-g`. For a near beginner this can be a pain. What do `C`, `M` and `S` mean? We all know now but how would a near beginner figure them out? What would someone search for? I bet some people give up because they don't know how to get google to tell them to go to some page at the start of the manual that tells them how to read it.Setting up emacsclient for file browser integrationThe built-in tutorial was great and probably hooked me on Emacs.Understanding elisp, figuring out I didn't need to use Emacs keybindingsI found it impossible to understand how to use keyboard shortcuts until I assigned caps-lock to be another ctrl. I feel it's quite absurd to expect newbies to use shortcuts like C-x C-f when "control" is so far away from the home row. Seeing the original "space cadet" keyboard revealed to me why the original modifier key choice is the way it is -- but on modern keyboards the overreliance on "Control" is a big problem for first-time users.The configuratiin language is confusing, and it's difficult to determine which packages are the popular ones and which are deprecated. I suspect that packages like Doom and Space Emacs address this these days.key bindings, configurationNot knowing C-h … family of commandsEmacs is unintuitive for people used to editors like vscode and using the mouse a majority of the time, so a mouse-based tutorial/walkthrough of the major functionality might be a good ideaelisp and not knowing about *info*My biggest issue was and still is getting a solid variable viewer in Python similar to what PyCharm provides.I had no clue about anything. The tutorial actually solved them.Help document is very kind. But, too long and too complex now. need turtorial like a game.Installation and configuration has been difficult, especially trying to determine where to place setq commands in doom.d configuration files, or when/how to use hooks. The doom/bin commands were confusing without a basic understanding of a vanilla Emacs+packages.el system. Change has been so rapid that videos and docs were frequently out of date. Also, determining what check-in/version to install has been a challenge as well as how/when to upgrade.It's a whole new alien set of keybindings and features and it's really quite overwhelmingThe configuration really sucks and there are thousands different ways to do one thing, also some old concept are still around and annoying for example a simple font face and size change seems to be a complex topic on its ownInteractively learning elisp within emacs was harder than it should be, propertizing text, key bindingsdiscoverability of features and elisp, too much customization can be harmful, outdated packages and documentation.Yes. It seems like there are a lot of ways to do the same thing. Try searching for 'how to set font emacs' or similar simple tasks. It can be extremely confusing.Learning the default keybindings. Now the difficulty is when anything else doesn't obey the Emacs keybindings.Strongly disliked how alien it felt on my mac. Added numerous keybindings to make it feel more integrated (cmd-q to quit, cmd-w to close a buffer, etc). And of course Doom helped it feel "ready" to go an more friendlier.Weird key bindings. It’s quite fragile - packages often break each other. Obscurity. Difficult configuration.It was sometimes hard to understand the documentation.Elisp is very different from most languages I had used before, so learning that was the most difficult part.Default keybindings for undo-redo are terrible.Started it and didn't know how to exit it.Built in documentation, info pages, a wonderful system in terms of accessibility, but VERY poor in terms of informative contents, perhaps the horrible markup used by info pages was part of that emptiness...I had been accustomed to Windows key bindings a few years prior.Lack of types was very annoyingTerrible default key bindings. Difficult package management. After installing package: getting it to load and activate modes in the right contexts.Mainly the key chords coming from very different software.complex key stroke. technical terms like frame or window, which are not like other UI.Syntax of elisp can be confusing at first. The sheer amount of packages and customization options are overwhelming at first.I mean come on it’s ancientBizarre namingIt took me literal years to understand the beauty of completion with tools like ido.A clunky UI (on MacOS), non-standard terminology, chaotic Lisp (e.g. hard to find basic string functions).Using emacs without memorising keybindings is hard, keybindings are hard to remember if not using them constantlyElisp is very much unlike other languages I'm familiar with and picking up the Lisp idioms just is a pretty steep learning curve initially (unlike LUA for instance). OTOH I'm aware that there's a reason why Lisp like languages are better suited to be configuration/extension languages. I guess I just have to stick with it. The out of the box keybindings in Emacs are horrendous. Evil makes it bearable for me as a Vimmer, but for somebody who doesn't have a background in Unix, it is enough of a turn-off to make people run away immediately.It took a very long time to learn how to customise anything substantial without causing breakage.Millions of keyboard shortcuts, misformatted codeIt is difficult to config Emacs to a point that is good enough to replace a modern text editor like atom, vscode, pager, etc.Elisp was jard to figure out. And how to structure my config to not make a complete messX11 was a dangerous virus; default keybindings had some unfriendlinesses; unqualified use of "Emacs" to mean one particular editorNot really, to be honest. I know I went through the tutorial, and made a conscious effort to use the native movement commands.Not really, if you start simple (with basically no setup, just evil mode if you're a vim user), you should be goodConfiguration: have to know the lisp syntax, and more particularly, the various commands (which never stuck with me)conflicts in the startup fileI was a kid and it was long ago...C-g ended up being way more critical than I thought and that wasn't explained in a super upfront way. I also thought the customize menus were really confusing. I didn't like how they edited my init.d! Doom fixes that issue well.Getting started with installing remote packages from m/elpa, and the discoverability of key bindings and commands. The `which-key` package, once installed, greatly helped me with this. Cider and clojure modes were also not as mature as they are now.Getting full window-system support took a long time and was a rocky path.After initially feeling a little lost (a few minutes), I discovered the tutorial and seemed to get on fine from there. I went in quite open-minded, though, and already knew a bit about the history of Emacs and that it was older than most common naming/key conventions I was familiar with. As such, I knew I should make zero assumptions about how it worked. I'm not sure that Emacs did a particularly good job of informing me of that, though.Missing features available in VS Code. I guess this could have been solved by Spacemacs/Doom, but I went the harder route of setting up a custom config myself.Keybindings Basic elisp concepts Emacs ecosystemEmacs lisp was my first lisp, but once I got over the lisp warts it was easyFinding a good configuration to write in Python. I tested so many different things. I now run emacs-lsp with the jedi backend. For a newcomer it's nearly impossible to find and configure this.muscle memory from previous editors. Select/Copy/Paste in WSLThe default key bindings are very different from CUA. The terminology is very different from what is commonly used in Microsoft Windows, e.g. frames and windows.- finding the "right" mac port (sorry, Mitsuharu Yamamoto's port is very much superior) - unconventional key-strokes for common stuff (copy, paste, etc)I have not yet found a good introductory text to Elisp (either too shallow or too deep). There is lots of information, most outdated and disgregated. There is a missing ladder between novice and expert.Debugging configuration issuesKeybindings and working with the keyboard (but I started on a VT100 coming from Macintosh)configuring packages and understanding which part of emacs is changing with installation another package from "top-10 best emacs packages"Not really. It a complex tool but the interactive help was always good.Waiting for access to the mainframe in the computer lab (it *was* wee while ago :) )High learning curve due to the configuration options.hard to debug start up scripts. many people start with spacemacs or doom (like I did) and then spend a lot of time tweaking a set up via copy and paste. this is slow and awkward1. Default completion system, I would prefer having something like vertico, consult & co. be the default experience 2. LSP support (essentially solved by eglot now being built-in) 3. Slow performaces (partially solved by elisp compilation) 4. Emacs should have a more modern and customizable UI. For example: an option for having the mode-line & minibuffer in the top area without having to rely on hacky solutions In my opinion something like rougier's nano-emacs could be used as a source of inspirationKeybindings were a barrier that kept me away for years. I don't mind them so much any more, but I use a mix of evil and default emacs bindings now.Configuring to my liking.No, Emacs isn't much different from Visual Studio, Visual Studio Code, Rider etc., so I didn't have difficulties learning it.Steep learning curve.How different it was from anything I've used in the past in terms of customizations.Setting up everything to be productive in a new language (or everytime the current tools break, and how long it takes to bring everything back together)Keybindings, terminal colors, finding the right lsp client (eglot), window managementCan't write code(go), no color, don't know how to set tab-space, no auto complete, don't what is lsp. Find company but don't know what is complete-frontend. Config all of this but it's very slow, always error.Making sense of the vanilla key mnemonics (which I used for a long time once I grokked them), feeling overwhelmed at all of the options.knowing how to use itSetting my init.el / emacs.d configurations for the first time due to elisp and being very different than any other programming language I used before.Memorize key bindingsThe learning curve was extreme, it took weeks before I could use it as a daily driver. Key binds, esoteric nomenclature, and a newbie-hostile culture were a serious learning hindrance. I tried and failed to adopt emacs multiple times, only succeeding when a coworker who used it daily was able to help me on demand.I found Elisp a bit cryptic, and I still can't really find my way around the documentation sometimes (the names of fairly basic API stuff always escapes me, find-file-other-window that sort)The daemon/client stuff is weird. Also, the keyboard shortcuts after using VS Code previouslyI learned the basics during a 4h train ride, but never extended the basic knowledge and capabilities.The learning curve is steep. I don't usually recommend it to people if I think they will give up easily.Discoverability -- TUI menus don't have an obvious way to triggerLack of tutorials. Some people learn better by reading text, others are visual learners. I feel that I excel as a visual learner and all of the official Emacs documentation is text-only. I feel that this is a significant shortcoming to a tool which is expected to be highly visual when used. This is a typical criticism about all FSF based documentation. Very little FSF documentation use visual aids.The keybindings are difficult and the barrier to entry is steep if you're coming from a more basic editor. For me having vim keybindings changed it all.Only thing that sticks out from over a decade ago is transitioning from using a mouse to using a keyboard for navigation, but of course this is not unique to emacs.Emacs doesn't utilize the muscle memory that the average person has for modern computers - the entire concept for how it works is foreign to a user coming from a point-and-click GUI background. I don't know how you could make emacs more beginner-friendly without losing out on some of the things that make it powerful (text-based configuration, the lisp interpreter)Default key bindings kind of suck but now I'm used to them. A lot of packages take way too much elisp to configure. I still don't know how to use most windowing functions and I'd rather it just used i3wm/sway/tmux for everything, like Kakoune.keybindings are not consistent or easy to use. I just started using Spacemacs (~2 mos.) which would be much easier way to learn emacs for a new user IMO.Keeping a heavily customized setup workingThe sheer amount of things and possibilities are very daunting at the start which is why I started with Doom Emacs. It showed me what is possible and also provided a modern experience. All of this knowledge is now used to power my own very opinionated configuration of Emacs. Another thing that was difficult to grasp was the configuration that is done in Emacs Lisp. Since I never had any experience with Lisp it looked very different to the programming languages I was used to which made learning it harder but still manageable. Moving away from the mouse and visual menus was another thing that was very different but I'm very happy that I made the switch.Learning curve is high to load the many key bindings into memory that are needed to do basic tasks. This would be true of any editor. Also, configuring Emacs to be aesthetically pleasing—it's simply awful out of the box.I started using emacs during a common lisp course and it was quite natural. Many of the navigation bindings are honestly bad and I'm just stockholm-syndromed into liking them. I always loved the undo system, something no other editor seem capable of getting right.felt very alient to everything else both on Linux and Windows: terminology, ui elements, ui element usage models, flexibilityLearning elisp to configure it.learning all the key combinations and commandsUntil I used elisp package like helm I have not understand the strength of Emacs Sometimes compatibility with Japanese IME is not good (Fortunately I didn't have difficulties with key binding matters because my dad introduced basic emacs key binding)I was struggled with configuration. I couldn't do it right at first.It was easy to mix up some of the keybindings, especially when sequences were required. I think there was a `C- ` and a `C- C-` that frequently tripped me up, but I can't recall what it was. Ediff is hard to use. I haven't used it often enough to become proficient, and I won't use it often enough to invest practice time. But I still want to use it. Emacs turned out to be bad for working with large files, and especially files with very long lines of text. It becomes sluggish to the point of unusable. For a while, I kept Notepad++ around just for working with files like that, which was heartbreaking.Dealing with a completely foreign set of keybindings - ctrl-c/v for instance.It took some time to learn the way Emacs works, spetially in relation to code results and exports, tanglingBack then I was mostly using Linux tty, where everything terminated on C-c. Emacs not following this convention surprised me at the beginning.Not a full IDE for JavaI still don’t feel like I know it that well. I’d like to learn moreKill-ringYes, I find the model quite confusing, and the documentation lacking for newbies. It took a long time to figure out how to do some basic things. Starting with Evil might have been a mistake, since it doesn't work in every screen, so you do need to learn some Emacs shortcuts as well.Key bindings were a mountain to climb, but the built-in tour did well to teach me them.Finding good video documentation/tutorials/walkthroughs. These really help a beginner imo, especially coming from something like Neovim or VSCodeI had to learn bindings. It's not that difficult, really, but for a migrator from a generally mouse-driven editors such as VSCode, it is a kinda tough step.Emacs is designed assuming that you will invest a bunch of time learning it. It could have a simpler core and advanced features that you could learn as needed.The internal logic of emacs documentation system was very difficult to figure out initially. Documentation Is fragmentated across many places and when used to searching for information on the internet, the incomplete nature of the online resources make it very confusing to figure out.Bit of a steep learning curve but very powerful!Emacs keybindingstoo many useless tutorial on the Internet. (Therefore I wrote emacs-tw/emacs-101-beginner-survival-guide)Non-sane defaults, difficult setup for begineers.Yes. The default bindings suck. Vim all the way. Learning emacs is very time-consuming if you want it to be useful for your projectsFinding out that “Emacs is an OS” has a lot of truth to it.Actually it was pretty easy because of the tutorial.Understanding the naming of the default keybinds (M-x == Alt + x)The lack of Emacs culture in my environment and the difficulty to make sense of the documentation without any guidanceThe self-documenting part is great but if you don't know how to properly access it that is annoying.Learning the terms that are used differently in emacs (buffer, window, frame, kill ring, etc.). Coming from vim, I had trouble with the amount of times that I would have to switch to emacs keybindings for various packages. This was while I was still using evil mode for regular editing.The initial jump from using emacs to configuring emacsThe whole package managing and configuration thing was kinda hard to adjustit's hard to switch from mouse driven navigation to keyboard driven navigation. you have to print or save a lot of cheatsheets. when you first learn Emacs you do not now about C-x being a prefix for a lot of things. and "C-x b" at first makes no sense. btw for me learning emacs keybindings were easier on IntelliJ IDEA. the other issue I had was "elisp functions vs commands" - when you search something on the internet it confusing when people sometimes write parts of elisp configuration that you should put into init.el and sometimes they write commands that you should invoke via M-xJust the absurdly high skill ceiling, so much stuff to learn, all the keybindingsI had never seen lisp before, default keybindings were very strangeThe keybinds were hard to get into at first.Hard to setup development environment for certain languages in order to be comparable to some other editorsyes, frame and windows managementI wasn't aware that there are groups of packages, where you choose only one of them, which combine bad with other packagesDoom Emacs specific but figuring it out which files I was supposed to edit. Figuring out how to debug errors. Figuring out how to see which executables are being used by emacs.Remember key binds. They seem so random with no semantics.key bindings. difficult to understand how to create major-mode.From nothing, reaching the point where I had a simple init.el set up with fonts, a good theme, basic interface settings, and use-package all configured and ready to go was the most difficult part, especially when so many online resources use very different approaches. I still have three separate functions in my init.el that set my font, and some combination of them seems to have done the trick. Beyond that, I think it was just having a use case that motivated me to take the deep dive into learning Emacs. It was ultimately seeing Elpy and Emacs-style interactive programming for Python that pushed me over the edge.Probably the default bindings. I wish that Emacs asked you what bindings (VIM/CUA/Emacs) you wanted to use on boot, or defaulted to CUA. Also I didn't find the welcome menu very helpful, I'd rather it just have a paragraph on how to use the C-h tools instead.Where to start; finding information; getting used to terminology (e.g. window, frame and buffer); how to start with writing my own config;It was quite difficult for me personally. First of all Emacs looked very ugly with that default light theme. Keybindings seemed weird because they are a lot different than in any other text editor (although Emacs is not a text editor bla bla bla...). Although I don't think keybindings should be changed since they are good since I used to it.It was very different from anything else I had used to that point, so it took a while to get used to the keybindings.learning curveThe defaults are quite a bit different than what I was used to at the timeBefore doom it was hard to set up lsp (2 years ago, for a beginner) With evil mode - it was hard to figure out even easy keymap modifications. Didn't figure out emacs debugging - whether it allows to step in function execution with breakpoints (as Common Lisp allows) Not easy to figure out which packages to learn use - tempo \ skempo \ skeleton \ yasnippets; ivy \ helm \ vertico+consult ; etc.Keybindings. Wrist pain.There are some features seemed unnatural for me: mini buffer, buffer switching, kill and yank, and keybinding like "C-x C-c."Official emacs (and elisp) guides are hard to follow if you never used Emacs with default keybindings.Too long ago.Remembering Keysnot much, it’s fun to learn emacs.Unfamiliar key kombinationsSome of my difficulties when initially learning emacs are as follows: 1. Extensibility is problem as well as solution. It was difficult (still is) for setting up Emacs as IDE like for angular projects (lsp mode, eglot) . Small bugs appears from nowhere. I like emacs simplicity, but Developers havent consider How to do things? , i mean officially, Like if i want to make emacs java ide, i want to go official rather following other code copying elisp and adding and breaking something . I heard eglot is being added i hope it will solve my problem. I like Emacs key bindings. But when we go deeper , vims binding is powerful and more better for long run. I want emacs key binding as well as vim (not viper) , I mean full builtin support for vim bindingsEvil isn't 100%. Some modes clobber evil bindings (or evil fails to bind over, not sure). Evil collection doesn't solve this problem well IMO.None. I just should have integrated more ELPA, MELPA, and Marmalade packages a lot earlier when I started using it.Writing my own .Emacs fileGetting it to stop applying GNU formatting conventions to C-family code.Scattered information everywhere to make the .emacs Sometimes outdated Too many similar packages and complementarity between packages hard to assesslack of helpful guides, and videos.Made the mistake of changing a bunch of things right out of the gate, target than learning the default way first.It took time to develop muscle memory of those keybindings. But after I had learned Emacs for a while, I just use my own keybinding to avoid ergonomic problems. Also Emacs Lisp itself is not a small language, if all Emacs's built-in packages are considered as part of its standard library.Slow startup times, until I discovered the daemon. RTL support.Configurations for citations and references in org mode for export to docx via pandoc.Configuring Emacs was daunting, so I went for Spacemacs. Now I'm having a difficult time creating my own custom config that's as fully-featured.Learning to configure it.the slang, getting it to be more useful than my old editor, understanding that modes are not as difficult as i thoughtI came to Emacs as a refuge from the scary world of Vim at college. Though I have made peace with Vim since, never quite left EmacsNo default setup, I found it very hard to set up a decent environment to work with C++ in. Both using vanilla + packages and using spacemacs. At this point I'm using vscode more because the constrained defaults make it easier to work with.Learning how the minibuffer and window management work. Yanking and killing text, moving the cursor from a buffer to the minibuffer, pasting text, and anything beyond basic motions and opening files (without Dired) were difficult. I still find Dired difficult to learn (though I have not visited the Info manual in some time, so that's my fault).Remembering the command keys.Key combinations can be hard to recall, and often I settle(d) on the "This is the way I learnt, this is the way I'll do it" approach rather than the most efficient approach.weird key bindings, obscure configuration options, ui feels obseleteThe main problem is the time it takes to get to a usable state. - set up the lsp (scala/python) - set up git integration via Magín - set a simple git gutter (still not working perfectly) — set the shortcutsSpeed of configuring, learning, getting productive quickly. Difficulty configuring for a code/debug workflow.don'dtt try to be smart ;-) starting simple and with the defaults is a better approach, rtfm :-)The lack of a gui to edit options, knowing what the options to edit even ARE, finding out what buttons to push to make something happen, finding out if I'm doing something a 'canonical' or 'efficient way', hoping what I'm doing won't break anythingI never sat down to learn emacs; I always had to learn enough of emacs to be able to get to other important/urgent stuff.God awful community and mentality (anti-CUA folks, folks who think the Emacs defaults are _correct_ or sensible, insults from Linux users who hate the rest of the world, everyone was very unhelpful (actually found racism in the community too)) Emacs' tutorial is beyond useless it actually hurts users and is a detriment to the application Emacs' defaults are wrong, pure fact (it needs to get with the century) [Copy = Ctrl + C, Paste = Ctrl + V, Cut = Ctrl + X ... undisputed fact] Emacs attracts a tons of nuts kooky people who make open source software a literal holy war (Israel and Palestine disagree less) Emacs Lisp is the absolute, unequivocal worst language I have ever used. My god what I would not give for an OOP language like Java or even C++ to write stuff in. None of the "distributions" (i.e. glorified custom configurations) are good (they are all their own forms of architected chaos and based on insane ideas) Emacs GUI/UX requires a lot of packages to fix it: Helm (my god, this is ONLY reason I would even consider using Emacs ... everyone needs to thank the creator), treemacs, flyspell, shackle (which is still very brittle), etc. Emacs internals are a nightmare to fix let alone expect a user to understand (good luck explaining packages, display-buffer-alist, ELisp syntax to anyone to just wants to edit text) The whole package "system" is the literal butt of jokes among the rest of the world that uses gold standard package systems: Nuget, Maven/Gradle, NPM, RubyGems, etc. ... maybe only C/C++ are as bad or worse than Emacs (but MS introduced some kooky package system that may fix it and is certainly better than all of the crap we have: MELPA [Stable vs Bleeding Edge], ELPA, Non GNU ELPA, plain'ol source) Basically, I only used Emacs because A) I was forced to and B) everything else sucks worse. The _second_ Visual Studio proper or Notepad++ come to macOS ... I am dropping Emacs like a bad habit.The keybindings. Of course, now I want to use them everywhere. Also, the non-standard terminology (frames, etc).Just needed to learn the keybindings, but it was fairly easy after a short while. To this day, though, I'm barely using 10% of what it's capable of. I don't even have an lsp server or whatever to look at my code. I just ... know the whole code base of 100k lines or so. lol.The giant blinking cursor drove me nuts. The white background color singed my retina. The key chords are unintuitive, and probably bad for your hands. The graphical menus are poorly organized. After realizing I'd have to spend several (dozens, hundreds...) hours learning about and configuring Emacs before I could actually get work done, I uninstalled it and went with VS Codium instead. But I installed Doom Emacs after hearing about it a few months ago, and have been happy with it ever since.Working with elispThe terminology used to refer to parts of the UI was confusing ("frame" and "window" have had very different meanings since GUIs became dominant). But it's not clear what can be done about this. Emacs was there first, and it seems unlikely to be worth the effort to change the names now. Coming from Vim, the pattern of strings of modified keys to invoke actions (eg, Ctrl-C Ctrl-X) was very alien to me. I avoided Emacs for years, despite suspecting it was better suited to me than Vim, because of the friction of learning the shortcuts and not wanting to reach for ctrl, meta, and super. evil-mode and frameworks like Spacemacs and Doom completely changed the game, and now I would never go back. But it does leave me somewhat regretful that I let the friction stop me from really trying Emacs for so many years.Not understanding how to learn it. Really understanding how to discover and learn new packages and commands took a year)Lack of guides to navigate the huge scope of emacs. Nobody tells you the good practices in a prioratized way. I mean, Pareto rule, what show I definitely know to use the editor and manage and understand Emacs as a platform effectively? What are the killer features I shouldn't miss out on. It's easy to get lost in irrelevant details and key bindings early on.Emacs is much more difficult to learn than most languages. You have to learn the keybindings (which are great once learning but there is a learning curve), configuring packages and settings using elisp takes a lot of learning even with things like prelude, and understanding buffers, frames, windows vs other editors is a lot different.I had no idea about lisp. I started with a completely vanilla install ~6 years ago and had no idea where to go from there."Whoops I fat fingered something and now I can't escape". Sometimes accompanied by my processor getting pinned and needing to kill -9 emacs.Learning curve is high- elisp is odd and complex - lack of good training materialGetting from "barely finished tutorial" to "actually grab things helping in productivity". Also, Emacs not having utf-8, which kept me with XEMacsMemorizing keys, understanding package features.key bindings.Reading the entire manual and not just fragments of textTerrible default window management.Weird key mappingtrying to figure out where my init.el was! From there, it was fairly incremental growthI cannot recall. I learned emacs many years ago when I had a lot more energy and patience. I don't know if I would be able to learn how to use emacs now.Opaque, steep learning curveNo, I followed along Prot's GNU Emacs series: .Remembering the keybindings. Getting used to key sequence of keys instead of [modifier+one or two keys]. Understanding Lisp.Yes. Vanilla Emacs doesn't have much. Learning how to install packages was difficult with different resources scattered online and multiple package repositories. Was very confusing.I had troubles getting a decent C/C++ support for my small projects. I wanted: - function signature hinting - function documentation hinting - some linting/type/reference checking - go to symbol I looked around and found CEDET which was very confusing to set up: - I wasn't sure which source to use (IIRC there were 2-3 candidates: CEDET1, CEDET2) - it required a lot of effort to get something to work, often copy-pasting elisp I couldn't understand - I couldn't find a guide which would explain me the principles of CEDET, I was just given snippets "if you want X please use Y code"I still have difficulties... The key bindings were unfamiliar.Elisp to configure everything.It's been a long time. I started using it on Windows NT, and I remember having to get some version called "NTmacs" or something like that. I guess getting off the ground with the right version is one hurdle. The other is that most neat packages are under non-default ELPA, though I guess that's been remedied with the new nonGNU ELPA repo.poor keybinding ergonomics by defaultThe untruth that Emacs is hard to learn and the community propogating that myth. No, you don't need to install this package or that.Difficulty in configuring + discovering what packages provide a good experience.1. Key bindings to move cursor (^F ^B ^N ^P). These bindings are not intuitive and hard to type. 2. How to use ^K, surprisingly it appends cut text to copy buffer and yank will paste all. The term "yank" is also difficult to understand than "paste." 3. How to use just copy but not kill. The answer is M-w. To find out, I browsed almost all pages of emacs manual.hard to memorize commands, accidentally typed commands I did not mean to and found it hard to get out of themKeybindings, plus navigating the infinity of options for packages and extensions (some crucial to the UX, such as completions, etc.)I thought I needed to use a starter kit. As a result I had a machine I didn’t really understand. After that I had a heavily customized configuration, but in the last five years my config tends to take more to prefer more stock settings and packages.Key bindings, I came from vscode and experienced a lot of friction with simple concepts like selecting text and copy paste.before I knew about Doom (have been a long time vim user) I tried to use emacs many time but could not understand where to start or how to go beyond the first hour of use. After starting with Doom, it was much easier and most of the struggling has been around understanding related issues (how to integrate emails with mu4e, how to work with org mode export, how to customize stuff in elisp, etc.)Mostly overcoming its sometimes odd default configuration while not yet knowing elisp. An example would be Emacs littering the filesystem with backup files, lock files and autosaves. Moving those to their own directories within my Emacs directory required (for a newcomer) non-trivial adjustments to a bunch of variables. Emacs also dumps a bunch of stuff into your init.el by default, but luckily that was easier to change. (custom-file variable) I am aware that this is because of backwards compatibility, but for a newcomer it is quite the annoyance. Or atleast, I would assume so (it definitely was for me), as no other editor I know of litters the filesystem like Emacs does and this default behaviour is also changed in configuration frameworks like Doom Emacs.The user interface by default is ugly, the splashscreen badly needs a redesign because that is what would drive some users away at first.reading elisp requires a lot of pre-education about emacs, most times the code is not obviousTrying too learn so many features and functions at once was hard. Learning the movement commands was also unintuitive coming from vim.At first, keybindings were confusing. Probably something similar to Nano interface could help.Spent a lot of time to get used to the keybindingsDifferent keybindings, also it was on Windows and many tools weren't installed (grep etc)Its slow because there isn't any multi-threadingopaque, hard to debug errorsUsing multiple configs, but that probably stemmed from O.S. fundamentals not being understood much. Also remembering some of the many commands.without doom emacs it's pretty much unusable. Also lack of proper multi threadinginstalling packages, learning navigation & buffer handelingThe tutorial focuses too much on keybindings, and not enough on why, the philosophy.Broken fingersvery confusing, no good tutorials (in the 1990s)The defaults sucked/made no sense, especially the weird half page scrolling behaviorIts just a steep learning curve, still learning after 25 years, but I love that tooThe default keybindings for common navigation and editing maneuvers were hard to type and remember, at least for me. The default completion UI was hard to use for me, and I quickly switched to Ivy, IIRC.Discovery was really a problem. The tutorial is very good, but it's also quite a bit to read and digest. Usually when you pop into an editor you need to get a task done, which is orthogonal to "read the manual" you just want enough to complete the task at hand. It's harder I think to get new people in because the upfront investment is pretty large.I started with doom Emacs, but didn't know vim well, so found it quite challenging learning both at the same timeevil is complexpackage and config management was not great back thenToo long ago to rememberBeen using too long, so can't really say; maybe a popup dialog box on first few runs ('this is a keyboard centric application; heres some great keys to know..')Keyboard shortcuts, elisp snippets not workingThe tutorials that I used to learn Emacs for the first time taught me to use Emacs from terminal. I would open a file, edit it, save and quit Emacs to go back to terminal to compile it and so on. Basically I was using it like vim, and of-course vim is much better at this type of use. It took many years for me to realize that I have to try Emacs more like and IDE , and not an alternative for vim.the key mappings we're very different, the whole concept of buffersThe key bindings are brutal. Evil gets in the way of some native keys.Very little. There are loads of great resources to learn from. I had more trouble setting up environment specific extras, like native-comp on MacOS, building Emacs on MacOS, etc.Deletion of data because of Crashtest and invorrect config Difficulties to get elisp Code snippets workingthe cluttered default out-of-box gtk ui and not knowing how to change it outside of the mouse menu optionsSteep learning curve for elisp- Learning key bindings was a challenge - configuring modes, .el files and additionap packages - online documentation wasn't very helpfuldebugging my own emacs script/package is difficult. the error messages are very hard to understand. the official document is not beginner-facing. most tutors used are written in too many versions by too many people.I'm currently learning Emacs, coming from a Vim background. Great experience overall. intro.txt was not enough, it includes simple buffer navigation and editing files, but I'm here for elisp, org-mode, dired, magit, and all the other goodies besides editing text. I couldn't find an introduction to tools beyond text editing. Is it either read all the manual or google search your way out.The obscure interface and lack of a conventional way to navigate code (features like fuzzy finding and a file tree) were pretty much my main difficulties.Installing spacemacs had me confused with it versions (stable not really used any more?) Some conventions alien to me. Not just the buffers, frames stuff, but when you get told "just paste this snippet to your config file" I don't know how to read the file to know if I've pasted it right (in the brackets, how many brackets, if I already have a setq bit then do i repeat it or paste just the other bits).Emacs was slow and fragile.All of the dumb jargon, like "buffer" and "frame", etc. get in the way.Learning the keyboard shortcutsThe documentation is written for technical people. As an academic using it for writing it was extremely difficult to learn.Finding out what keybinds do in any given context. Losing my windows/arrangement whenever a transient buffer took over. Not being able to click on things to interact when browsing. Not enough discoverability in the File menu.Find out which packages/practices are outdatedkeyboard key-combinationsNo, it was a clear step up from ed. I did often have to compile Emacs myself, since sysadmins didn't like that raw mode slowed down the Vax we were using.The font config is confusing...Switching around between buffers. Working out how to run code.Learning the lingoerror messages can be very confusing, exploring the usage and package landscape to discover what was capable. Not all of us are programmers by trade and so possibilites are not immediately obvious.When I started I didn't even know how to run commands. It took me a long time to realize I could M-x to run any command.You need a lot of boilerplate configuration before getting started because of emacs bad defaults.Bad performance when not used correct, not enough good and quick tutorialsMuscle memory of many keybindingsfiles / dir navigation is unintuitive by default. It is also troublesome to setup a working environment for python.Coming from "modern" text editors, there is a very steep learning curve to navigate the application, use keybindings that don't conform to modern standards, or do what other editors consider to be basic functionality, such as alt-moving lines, commenting out blocks, indenting with tabs, or navigating project files.Package ecosystem pre package.el Dated and unexpected defaults (backup files etc)I had some difficulties migrating from my productive vim environment and adapting it to emacs. Like I couldn't map C-[ to be the escape key in some cases.It felt like it was more complicated than it wasI think the movement is the hardest part. Once you have that down everything else is pretty easy to learn.Learning the new (old) terminologies and relearning the text editing flows/techniques.Initial keybindings and configuration were very difficult to overcome. Meta, Control, and Shift key combos are hard on the hands at first. It's hard to see the long term value when you're first getting started. Nowadays, if you plug in helm and magit you see the value in seconds.Old school shortcuts, very specific/unique terminology, experience/familiarity with REPL instead of compiled codeI had learn both vim and Emacs at the same time with spacemacs. Basic navigation was a huge issue, second to poor autocomplete/formatting issues.I wanted to switch over many times but kept bouncing off the complex key bindings. As a vim lover, I tried spacemacs a couple times but it was very problematic. Eventually I tried doom and suddenly everything was good. The learning curve after that was minimal.Configuring Emacs takes a lot of time. Unclear how that all works initially, and still. Unclear why the shortcut keys are this way. Thinking of switching to vim key bindings, trying that out, breaking many packages. Then using Doom, too many things configured that can all go wrong.kek noI was fortunate — in 1980 I was introduced to Emacs by (now-Dr.) Mabry Tyson at the UT Austin computer science AI department.Before adopting Doom Emacs I struggled a lot with configuration. I made several attempts to switch to Emacs and sometimes spent weeks trying to get it to work in a way that would satisfy me, each time giving up in frustration. Doom was a great enabler for me.to understand read vs eval (quotes) in elisp- keybinding that was not easy to learn - vanilla emacs is not helpfull when learning a new languageUnderstanding syntax for configs and using external packagesKeybindingdJumping from a beginner to intermediate level user, Errors in my init config made me reach for other text editors in order to fix themGetting used to the buffer system was a challenge initially. Then, I struggled with configuring options until I learned to it the init.el file.Elisp was harder for me because Emacs and core APIs weren't very well-organized internally, back then.Remembering all the keyboard shortcutsthe unattractive interfaceKnowing how to use it and do stuff. Knowing which keybindings to use, how to install packages, customize thingsEverything was difficult but it was part of the charmhard to 1st use, GUI not modernismEmacs specific lingo is hard to understand (buffers/windows) Keybinding symbolization is less standard C-x -> Ctrl-x/RET -> Return (only minor, but not super obvious)The vanilla keybinding are not approachable CUA mode helps but it makes doing operations on marked text difficult.Learning the keyboard commands, learning how to configure your init file, learning and configuring LSP for your projects, stuff breaking with updates, getting it to look better, learning how to use org-mode.Complex configurations with lots of packages require extensive learning about all of the components and how they interact. I'm still struggling to learn it. But I'm already addicted af.Didn't know where to start, which documentation to use because vanilla emacs is very limited in functionality and very foreign for newcomers. I was using spacemacs at that time, so trying to learn it and vanilla emacs was too much.It was hard to know what to look at because so much of the screen was changing. Even as a vim user it was hard to understand where to look.Remembering commands, learning elispLittle support available for some specific issues through googleNo clear documentation nore tutorial to configure emacs clearly from scratch.God yes. Everything. It was brutal. Discovering functionality was rough.After the initial installation I didn't know what I could do with it and where to start. There is no package gallery or a showcase of what interesting things can be done and why I should use it, and the available resources (videos, tutorials, etc) that I found were not beginner-friendly. Today there are channels like System Crafters which make make it easier to find a way around starting from scratch.I cant remember that far back. =)The barrier to entry is so highWhat to use: XEmacs vs. GNUThe out-of-the-box experience is not as good as in other IDEs for programmingEmacs vocabulary is really hard to get. Frames vs window. Buffers, etc..Too many options for learning when all I wanted to do was write and edit text. I found the in build tutorial more helpful initially then anything elseinit.el or config having bugs, laggy/sluggish, bugs (such as C-c C-c not closing captures), getting a tool to do what you actually want vs what someone else thinks you want (this is emacs' strength but it's non trivial), emacs customize menus and file are still a mystery to me.Before I learned to remap the control key to caps-lock, I found the default bindings VERY uncomfortable.Yes, completely missed the point the first time - couldn't work it out of the box. The second time I got it working by borrowing another user's "init.el" file. The third time was lucky (about 6 years later), I managed to write.Default look is pretty awfulThe keybinds were very unfamiliar, and the experience felt like using an archaic tool.Keybinding: find how to do something or what a key binding does Package: feels hard to get in Find resource on how to get more productive, customize our needsThe default key bindings Unfamiliar nomenclature- not having a consistent way to install and learn about packages. - terminology specific to emacsAt first I had a lot of problems with performance - it took some time to learn to debug what packages/bits of config caused a performance impact and to circumvent those while retaining the functionality that I was looking for. The terminology in the documentation took some getting used to, but I'm glad there's as many docs as there are and can only wish for more. Apart from the Emacs internal docs, package READMEs have always been very useful.Tried to do extra things with emacs, e.g. setup packages for everything in a row.- Learning how to install packages - Figuring out how to globally remap cursor movement to i,j,k,l buttons, which i'm currently using a minor mode forThe keybindings take a while getting used toFrequent crashes (not anymore). Slower than my neovim config of 1,600 lines of vimscript (much better today).The manual, specifically the separation with elisp. Default keybindings too cluttered, cause people to communicate about bindings rather than function names. Tons of cargo-culted configuration styles make it difficult to reproduce others' results. Tutorial is focused on superficial use rather that elisp interaction.I had a very good support network around me when I learned Emacs. I think it might have been more difficult if I had not had people helping, but it was a long time ago and I can't be sure about that counterfactual conjecture.external packages vs built-in functionalityconfig file in Emacs lisp syntax, which is nothing about human readable.Had to figure out the key chording patterns.Didn't know where to startNot very modern Keybindingsthe GUI-ness of emacs is fairly generic as expected by the wide-platform support that is needed. As a long-term user who is still a (true) novice, I still find that true beginner-level help is difficult to find. And, the migration of many 'how to' instructions moving to video means that a great deal of useful information is only findable by watching videos (slow). You ask about frameworks earlier in the survey. I have not looked (so it might exist), but a framework browser might be nice.Overcoming my CUA muscle-memory.Remember keybindingsInstalling packages, getting packages to work together, picking a good "starter kit"Pinky pain (RSI) with the default keystrokes. Vim and Evil helped that a lot.The default setup is austere: no electric-pair-mode, no hl-line-mode, no show-paren-mode, etcI was used to CUA shortcuts.Difficulty getting my head wrapped around lisp. Difficulty remembering/understanding shortcuts.- I still have a really difficult time writing Elisp. It takes me at least 5x longer to write Elisp than Python - Until I found spacemacs, I was really confused by Emacs keybindings and setup, and by older, low-quality info online.difficulties to understand the logic of the softwareThe default keybindings. Switching to evil mode and leader-key made everything easiersteep learning curve, unless you start with doom or similar, you need to put many hours into it until it becomes better than the competitionThe key chords were unusual at first, but once you understand why they become "natural"I still don’t really get Elisp what that’s mainly my own fault. In addition it took a bit time until I understood all the related words (buffer, etc.)It’s a steep learning curve for sure, cannot recall any specific examples.High learning curve and minimal “beginner” documentationemacs lisp is confusingWhen I started using Emacs (early 90s) it was not as easy as it is now to find resources on, e.g., quirks and obscure features of Elisp, etc. Even the key bindings seemed pretty unfriendly.Faces configuration- I'm still learning. - keybindings took a bit to get used to - the default was ugly and the customization I copied from my supervisor didn't always work correctly (e.g. code conventions for C++), but I didn't understand it properly - we had an outdated version at university which made packages often incompatible with the version on my laptop (think something like emacs 22 vs 25)Having to adjust to the emacs-native keybindings proved to be too much at once. So I configured evil-mode to help with the transition from vim to emacs. I plan to eventually get rid of evil-mode as well.The time it would take to learn a new set of keybindings -- Up until I found spacemacs.Learning lisp was a bit (though not much!) of a challenge given how different it is in syntax to most other common languagesUntil the power of macros sank in it was just a novelty because of elispAt first it was hard to jump in because it felt very magical But that faded and I learned the scienceCan be confusing at first as it has a learning curve. The default keybindings can be turn offs for people who are quickly looking for a text editor.At the earliest time I found it frustrating to navigate the new keybindings and recall what key combinations do what. The tutorial was definitely helpful for this. Also, understanding what is meant by self-documenting really helped me feel more comfortable to explore what I need, without trying to understand the whole system at once.- the keybinding system took some time to get used to; - no real programming ecosystem (getting better and better) meant a lot of time spent trying to figure out how to make things work;The default key bindings hurt my hands.sdfIt took about 2 weeks to get a usable configuration.Doom Emacs hid the complexity of Emacs which caused extreme confusion while trying to fix nearly any issue; i would not be using Emacs if it was not for Doom, i am grateful for it. Setting up spellchecking for multiple languages at the same time was difficult.I have no idea.I came from Vim so most of my difficulties were in setting it up and replicating the features that I had over there. Vim is a superior text editor IMO but a much worse piece of software.keyboard movement not as fluid as vimIt’s not easy to find out where to look when you want to customize somethingSome emacs tutorials presuppose UNIX knowledge. Spacemacs helped a lot.Being told to not use menu-bar and tool-bar.Outdated defaults and terminologyThe default shortcuts made it extremely difficult and not intuitive. The default user interface is very poor. The terminology was confusing (still is).When just starting out, I regularly pressed the start of a key cord(C-c, C-x) by accident, so I'd get frustrated with Emacs not doing what I wanted. I now know the visual cues for this, but they're fairly unobtrusive. Also, I'd hit C-z quite often and get frustrated with the window minimising.> Please be as specific and concrete as your memories permit. Sorry that was too long ago :) I think I started using technomancy's emacs-starter-kit. I remember that package.el+use-package was a game changer: it provided a clear starting point(s) to integrate packages and later make my own. Before that I was lost in the jargon (window/frame? minor mode? hook?) and kept going only because vim's support for lisps at the time was inferior.1) Terminology appears to newer/younger computer users as outdated and stubborn. This is more of a social issue, but insisting on calling the "alt" key "meta" and calling "windows" "frames" is off-putting. It made me uneasy about spending significant amounts of time into a system that I might not like. 2) I was not yet a vim user, but had been learning vim keys and really liked them (most of all hjkl). The standard emacs keys are awful. There is also A LOT to learn before you can use it for even basic tasks. 3) I first came to emacs from Doom Emacs and it was great using the space bar as the start of all commands. It is a great way to enter commands, and unfortunately emacs doesn't work like this out of the box. I wanted to learn emacs from scratch so ultimately went to vanilla emacs... to once again suffer with the standard key bindings. 4) Linux Mint did not have close to the latest version of emacs. For the latest I had to build it and this was not easy for me as I had never done this.Many non intuitive commands and key bindings. I still struggle with this.- nomenclature (window, frame, buffer, minibuffer,kill,yank,..) - but it gets better - key bindings (thank god for evil) - window configuration (this still feels like a „random behavior generator“)memorising key bindingsthe first moments are very difficult because emacs is so much different than other editorsAt least for me, needing to learn to at least understand e-lisp despite not having seen it before. I could copy-paste code and see it work but I had issues understanding what it did at first until I learned to read it. Now I do most of my scripting in elisp.Emacs needs some focus on package installation/management as part of it's getting started documentation. Adding a section on package management to https://www.gnu.org/software/emacs/tour/ would be incredibly helpful. For the modern developer, much of their expectation of an editor is set by vscode, visual studio, and intellij. As such, their immediate concern is "how do I start a (typescript/java/clojure/etc) project?". Focusing on appealing to that perspective in the getting started documentation would go a long way towards adoption. Understanding from the get go that you can shell invoke `npx create-react-app my-app`, `M-x package-install`->`typescript-mode` + `lsp-mode`, `M-x lsp-install-server` -> `ts-ls` would go a huge way towards making emacs seem more appealing to a typescript developer, and equivalent examples could be made fairly easily for any language with wide adoption. Additionally, keybindings are another of the biggest hurdles for new developers. I came from vim so this wasn't a big issue, but emphasizing that users can freely rebind keys and pick distributions that bring default bindings to everything would help new developers as well.C-x C-cFor most things that are not built-in, there are several alternative packages and it’s often difficult to figure out which alternative adresses the need best.I was used to Vim keybindings, starting with a config from scratch that used Vim bindings everywhere was hard. Doom helped with that. Concepts/naming are a bit different but that was cleared up fairly quickly. Learning elisp was a challenge at first, I didn't have any Lisp experience beforehand.Mainly: 1. Understanding the differences between the various builds of Emacs at the time (aquamacs, xemacs, emacs, "emacs-nox", etc). 2. Finding intermediate-to-advanced documentation on Emacs Lisp (like how to write major modes, font-lock rules, write completion-at-point backends, do concurrency, etc). Despite a very detailed manual, it was difficult to know where to start, and I ended up finding most of my answers by studying Emacs' source code (C and elisp), which, in hindsight, was very inefficient (though enlightening). Besides these two points, I did not have any particular difficulties getting into Emacs, and discovering Evil made the transition very smooth.Feeling productive, keybindings were hard to remember and get a handle on, after years (and reading mastering emacs) I have a handle on it. early days (emacs 22/23/pre 24 ish) were challenging to manage extensions. Cedet was never quite there for C/C++ completion was clunky, this is all mostly solved with packages from 24, other quality of life changes coming in 29, and various speed ups available in 28.A few really odd defaults. Lots of missing functionality. So I started my own config with additional packages. Wasn't great either. Collapsed a few months ago. Now I am a mostly kind of happy doom user fighting with a new set of odd defaults :-)Pre-LSP, getting code navigation / completion workingWindow (not Frame) management, getting different packages to work together.Key bindings. (Undo / redo even today)I have had trouble getting used to the workflow of Emacs, as it is quite different. I also still sometimes struggle with debugging some issues; as I'm still fairly new to this program.relationship and difference between window and buffer.making emacs convenient in basic things (navigation, opening/saving files) after easy-to-use editorsI didn't know you could do index search and full-text search of the Emacs user manual, and this was not made obvious in the manual because this is an Info-doc feature. How to search for functions by name, how to search for a key binding by function, and how to search for which function is called by a key binding -- all should be explained in the very beginning of the tutorial.elisp is hard if you never programmed on anything lisp like before.The concept of chording took a bit to get used to, escaping from the mini buffer when messing up commands or getting lost/confusedNavigating directories was a painLearning to customize it to act like vim was difficultResources to learn Emacs.Command discoverability is difficult at first1. Unhelpful error messages (even with --debug-init) that made bugs in configs hard to track down. 2. Subpar documentation in Doom Emacs. I would have loved a nice concise guide, so that I don't need to learn keybindings and available features through which-key and search up included packages one by one to see what they do.tutorDiscoverability was a problem. Which-key and completion frameworks (helm, ivy, etc) greatly helped with this. I did not find the built-in tutorial helpful. I had trouble retaining the lessons it taught. I used spacemacs with helm for a while and that helped with discoverabiliy of keybindings and concepts.Default keybindings for undo and redo.It was a long time ago, but the defaults back then were just as awful as they are today. CUA should be the default, especially on macOS, where e.g. Cmd-C does not clash with C-c. Point and mark are powerful tools, but they are less intuitive than simple selections. I think the biggest initial hurdle was discoverability. The tutorial does a great job at explaining how to edit files, but barely gives you the pointers for things like M-x describe-function, etc - so it's quite difficult to "discover" things like M-x align-regexp, which is absolutely fantastic (but only once you know it exists). The customize GUI is a good step too, but 1. there are waaay too many options (so you get lost trying to use it), and 2. the more options you set, the harder it is to transition to a proper, customized init.el file - the two don't play nice. In my first few years of using Emacs, I've barely "progressed" beyond using it as a basic notepad.Keybindings, understanding elisp, not going down the package rabbit holeMemorizing the shortkeys.The fact that the keybindings and underlying concepts are so different from modern applications (kill/yank instead of copy/paste for example) required a lot of adjustment. Solving these points of confusion was also difficult since there are so many resources that solve problems with various degrees of age/specificity/being well written/actually solving a given problem.Initially, the keyboard stumped me. That version of Emacs (18.x) didn't come with the info files nor the tutorial.I was new to Lisp syntax, and I was coming from Object-Oriented Programming, so it took a me a while to adjust.Lisp! The default UI is ugly and dated. Understanding how to tweak .emacsJust getting used to the paradigm. The built in tutorial is great.1. Concepts like buffer/window/frame were not something I was familiar with and it was difficult grasping them. 2. Keybindings didn't make sense for a long time until I read the function names and understood history (eg. yank was weird). 3. It is not the most beginner friendly experience unless you have a resource that you can access for help (an experienced user, for example). The manual is too big to read if you are picking up Emacs while also getting work done. So someone telling you to try the X feature or the Y package is crucial to get the most out of Emacs.It was even hard to open a file and write any code. I was typing wrong keybindings all the time and it was making me angry.Lisp is weird. Loading sequence unfamiliar.The help system took some time to get used to. There were configurations that sped up performance (for example, setting gc-cons-threshold) that I stumbled upon by accident and I feel like they should be much more clearly communicated. Lisp was very different from other languages (java/js) and took a bit of time to get used to. There were little to no intermediate level tutorials/blogs, only beginner level and advanced (beyond my comprehension at the time).Emacs keybindings are horrible, and the Vim emulation is not very goodCopy and pastingKey bindings, customisation.Learning the concepts behind emacsIn that day it was hard to get all parts from kermit to shell to Emacs to agree on a character set for my language.How to get the most performance and how is the init time affected by require statements.Moving between buffers.Emacs' jargon: windows, frames, buffer, etc.I found the guided tutorial (C-h t) to be too long and difficult to get out of. I learn best by example, so reading through the keybindings (C-h b) was the best starting point. I also sometimes forgot the 2nd Ctrl in certain sequences (i.e. pressing C-x s instead of C-x C-s) and would stop holding the Ctrl key too soon. I've since outgrown that habit.horrible defaults settings for no valid reasons (historic reasons). They should just pin a set of default settings at startup when no settings are set for each new release. This would allow updating settings (to better ones) without breaking retro-compatibility.Terminology (e.g. buffers, files had non-intuitive meanings). Keybindings were strange (not CUA!). Although links to the manual were right there... I never really understood how helpful the documents could or should be!Learning the keyboard commandsC-h r focused too much on non-essential functionality. I would've preferred being introduced to certain modes, magit, and maybe doom back in the dayDo not know how to navigate, copy/paste, no idea what buffer is, do not know how to open file, how to use dired, how to install packages, etc.There is a lot to learn, and important to understand that you can learn one piece at a time to not get overwhelmed if you start with vanilla Emacs. I am still "initially learning Emacs" and will probably continue for years to come, but after some months of use, I feel that the effort is starting to pay off since I get the efficiencies of having lots of tasks integrated into one cohesive workflow inside Emacs instead of using separate programs for email, RSS, terminal emulation, text editing, word processing and PDF document production. There are still things I do outside of Emacs like calendaring that could be integrated that I have not had the time to properly investigate yet.The default keybindings were hard to remember.Everything! Thank god for video tutorials. Org mode was my gateway drugWas quite smooth, started with tutorial and then went to infoI initially started with Spacemacs, which had some issues during updates. In my own configuration, I use `use-package', which unfortunately only has the necessary documentation on its README, not in its info pages nor in its internal documentation, which makes it frustrating to troubleshoot when offline.I use Emacs shell-mode as a terminal emulator, since I encountered difficulties with ansi-term; e.g. being unable to get out of the buffer, since the key bindings were different.Browsing Info manuals. Some configurations can be a chore to set up (disabling backups, ensuring UTF-8, configuring tab behavior). "setq" feels like a noob trap, and I had to read "customize-set-variable" source code.Setting up configurationThe keybindings were a little tough to get the hang of at first.Where to find helpHard to get started, OS incompatibility, slow, features not discoverable at all.I don't remember, that was too long agoIt was very difficult to set up mu4e with very limited previous knowledge about anything related to it. Out of all the resources I looked into most were either so general that I didn't know how to apply it to my own case or too specific and specialized. Additionally, dependencies on distro dependent programs external to emacs made things much harder. Also, it's often hard to figure out the features a package has and how to get started using it.Nothing specific. I think I got more comfortable after skim-reading mastering emacs. The built-in tutorial was enough for getting around but not enough to "impress me positively".Key bindings and terminology took some time to get used toIt was hard to understand what happened to a buffer once it went into the background.Key bindings till I found the way to tweak it the way I prefer it (brief)Key bindings, getting it setupOnly that Emacs placed backup files in the same directory as the file you are editing. After researching the topic, I just placed them into a seperate directory.Configure Emacs properly (now I have a structured init thanks to orgmode and code blocks), remember keybindingsKeybindings, building the latest and greatest.Discoverability of keybindings / features : frustrating in plain emacs / spacemacs, made me try and stick to doom.It took me some time to get used to the lisp syntax. It took a long time to reach a satisfactory setting.Definitely Elisp, It was my biggest hurdle to enjoying Emacs. I remember using other peoples configurations for Emacs and feeling very unsatisfied (keybindings, weird defaults, theming, etc). So learning how to properly configure and theme Emacs in Elisp (Xah Lee, Emacs FAQ, EmacsWiki) was a worthwhile but difficult experience.Init and configuring files.Different key bindings that conflict with the standard OS key bindings, the point doesn't remain in place when you scroll to another part of the document so your edit line is lost, weird scrolling behavior (jumpy until smooth-scrolling-mode installed/turned on)Finding out commands by the written representation of the input. For example `Alt-x` opens the command filtering panel. Would be nice to be able to write the `SPC` there and see all commands that can be activated by starting `SPC-`.Better elisp package writing documentation.Still learning.Findin packages and tweacking them to suit my needs.I started with spacemacs, but found it to be too slow. It took me quite some time to start from a vanilla configuration. I looked at a number of Ruby developer's configurations to get insight and slowly built my current configuration.everything, the concepts, finding the doc, making the keybinds. I just didn't see why someone would like to use that.The biggest difficulty when using Emacs for the first time was memorizing the keybindings and studying Elisp in order to write a useful configuration to adapt the editor to my various needsSetting up environment* atypical naming: windows, frame, yankThere no such out of the box configuration for new beginnerkeystrokes :)Discoverability was difficult until I learned "the emacs way" (apropos, which-key, etc...)tag files were hard to get around. I like the way vi uses tags but I use lisp code someone developed for tags. That works good enough for me.i mostly did'nt have, but i was struggling to find the cool keybindings before i used which-keyusing ctrl key.Bindings are more annoying than vim. Using evil mitigates this, but (even with evil-collection) makes bindings inconsistent in some modes, making it harder to explore and learn new modes.elislpthe functionality of the editor seemed quite disorganized & not very consistent; I had a similar feelings towards elisp initiallyNot sure of what my configuration will do because of lack of experience.no sane defaults, and while over time I got (very) used to emacs' particular brand of discoverability, initially I had no idea of all the things it could do.MotivationKeybindings. That being said, that was only for a brief period and I got used to the default bindings relatively quickly.learning curve, key combinationsLearning keyboard commandsThe default keybinings proved very difficult to use as someone who was used to CUAEmacs is very arcane! Learning about buffers, basic Emacs Lisp, how Emacs works, things like that!The learning curve required rewiring my touch typing muscles to the Emacs key chords. It took time to become familiar with Emacs' naming of concepts and nomenclature which differs from typical Microsoft-style verbiage.- Keybindings takes a while to get used to. - Many features require some package setup, like LSP, autocomplete, to feel more like a code editor. - Emacs-Lisp is quite different from other languages I was used to, so setting it up was not that easy.how to adjust my workflow where I compute on a remote machine. TUI and vterm (or shell?)? TUI, tmux, actual terminal? GUI, terminal emulator, tramp? GUI + tramp, tmux, actual terminal?Not knowing where to start. There's the keybindings, the functions, elisp, frameworks like doom, spacemacs, etc. It was very difficult to know how to sequence the things I was learning. For example, should I learn the emacs keybings at all if I want to use evil-mode, or should I focus on learning elisp?That it wasn’t a CUA environment. Nothing about frames/windows/buffers made sense.- Naming (e.g .copy/paste vs kill/yank) - Shortcuts (e.g. cua mode) - Using emacs in a corporate Environment on WindowsChanging the default key configurations into something that makes more sense for meNothing in particularwhere to beginLearning lisp.poor defaultsElisp was difficult to understandSpaceemacs had manual with wrong keybindings that took me aback for quite some time. Also there are complex concepts of org-agenda, scratch buffer, buffers themselves, need to keep emacs open instead of closing it after each edit.kept hitting ctrl-zLearning elisp, configuring takes quite a bit of time (but it's worth it).Figuring out how to do simple configs and troubleshoot flows (inspect a variable, figure out where to change it, where some piece of code is coming from)The keybindings took some time to learn. There were a lot of features and I often felt lost.I had a mentor and a cheatsheet, so I had help.Understanding how packages and add-ons work - how to properly initialize them, how to learn their keybindings, how they interact with other add-ons. I have spent many hours trying to enable or disable minor modes that I do or don't want but aren't well documented for non experts.Keybindings was strange, lisp was entirely new- Configurations as code instead of a wizard - New key bindings - Too many choices to decide without previous knowledgeRe-learning space-based leader keysElisp, bindingsThere are a lot of commands to use.The initial setup looked very ugly, this turned me off. Additionally the default Keybindindings hurt my fingers and wrist (I really tried to love them, tried for multiple months) Also setting up Emacs to be productive (and not an eye sore) took very long. Both got solved when I found Doom Emacs later.Arcane sounding terminology, foreign default keybindings, general lack of UX compared to most other modern editors. Lack of popularity compared to even Vim doesn't help either.Keybindings, ELisp, UiThe tutorial still starts with keys like C-v (scroll-up-command) early on. Even 35 years ago I had a page-up key on my keyboard which worked with Emacs. Why would a beginner try to memorize C-u 3 C-p when hitting the up arrow three times does the same, only faster, and doesn't waste brain cells?My dependence on evil is still a bit of a issue - when I first started I ran into many places where the keybindings for various modes weren't compatible with evil and customizing was hard within the framework of something as complicated as spacemacs. I feel much better about things now that I've learned some elisp and have just written my own config files from scratch.Started with a starter kit and was confused what features/configuration came from Emacs and what came from the starter kit.Learning what exists built-inrelearning keybindings / unlearning CUAFamiliarizing myself with elisp. Learning chord combinations.Faces continue to be a pain to work with. The portability of config continues to be the reason I use vim on a lot of servers, trying to TRAMP something 3 hops deep from the command line there is a pain.Didn't know what "M" meant in "M-x"... for me it was "Alt". I also didn't really discover the help system early on, and was very confused for a long time. I found various bits on google but once I really figured out how to use the help system, I started learning faster as I could help myself (and many things really are documented if you know where to look).Learning lisp to configure emacs was a challenge at firstGetting a workin configuration (e.g., language documentation while editing, code completion suggestions)Learn shortcutsI started using emacs when USENET was popular and the biggest problem in those days was finding people that could answer questions in a timely manner when the documentation wasn't sufficient.Learning the new keybinds to accomplish tasksThe number of options is overwhelming. Defaults are not great.The defaults are bad, which means you spend time searching basic things in the beginning, like when selecting text and then typing something will not delete the selection content by default. Then you sped time searching how to do it until you find-out about delete-selection-mode.Finding a system where the sysadmin would install it.. (I did say 33 years ago)PATH, spacemacs was slow and unstable at the timeWell, I had to learn a completely new language to customize it.Elisp was a challenge. Still is.Performance is noticeably worse than neovim, there's some input lag where there should not be.It took me a while to understand `setq` vs `set`, general elisp quoting stuff (I still forget it sometimes, I write elisp fairly rarely), and where to place configuration to run at the appropriate point of startup in the framework I was using at the time (maybe prelude?). In addition I find elisp associative arrays clunky/they don't work great for me sometimes?Yes -- the keybindings are very counter-intuitive to every other program made since Emacs. One of the difficulties I've learned to live with is how inaccessible it is for people with weak eye-sight -- it's impossible to easily zoom a document for temporary magnification.difficult to learn since it has so many methods of interaction. difficult to configureTerminal misconfiguration. It was a long time ago.Learning elisp. Keybindings were difficult but now I prefer themUnfamiliar terminology and naming used in the introduction tutorial and some function names. Confusing Installation and configuration instructions for external packages.Default key bindings were really annoying.C-g as the cancel was my first problem.Learning Elisp and the huge ecosystem of packagesThe keystrokes for each mode can be hard to learn.i had problems understanding how the init file works (and also its location)The keybindings were very different, as well as concepts such as buffers, which were unintuitive for someone coming only from a windows/tab based experience. Of course, once your learn these things happen to be quite powerful.It was not natural to switch between file, or find file.New keybindingsRemembering the chords for anything I don't use on a daily basis. Also looking up chordsLisp was hard for me getting used to.The keybinds were hard to remember so I switch to evil mode fairly quickly. Some of the vintage terminology (buffer / window / frame / point etc) is hard to get your head around while also trying to learn a complicated piece of software.Memorizing the keybindings and understanding how to install packages.To work effectively, you must master the basic key commands; there is no way around this. You must develop 'muscle memory' in your hands like learning a musical instrument. It takes time and practice.Emacs keybindings caused RSI flare-upsUnderstanding elisp and how emacs core works, single thread, buffers etcRemembering shortcuts was hard, and finding buffers.- learning the UI/UX primitives took time and patienceLack of structured learning path apart from the inbuilt tutorialAncient terminology, and odd ways to do stuff compared with modern day editors.package management, configuration, and key bindings are unnecessarily complex. an out of the box good experience is lacking. in my view, these are problems that are solvable.Keybinds, philosophy for extending it,elispIt was very hard to adapt to a system that didn't use modern GUI conventions (e.g. cua-mode, windowing terminology).The tutorial took some time to absorb. The conventional undo was tough to grasp.well, i'm still learning the commands.Lacking some IDE-like packages installed ootb (eg.: company, projectile) is a little offputting.Didn't know about places to get help (ML/IRC/etc)Keybindings. I did not know that packages exist.Not really, but I've learned emacs very very slowlyMost of the issues were related to the specific language tooling and extensions. Being a previous vim user, I felt quite at home when using Spacemacs or Doom, and I could pick up most Emacs idiosyncrasies along the way. Although some concepts took me a bit more getting used to, like the distinction between windows and buffers, at the end of the day I wouldn't change any major design decisions.Not a difficulty on my point of view, but rather a disappointment after being greeted with the ugly default interface. I went back to try Emacs after jumping on doom and spacemacs which had pretty good configuration and looks out of the box, that encouraged me to invest more time on Emacs.Key bindings, terminologyIt took some time to get used to the multiple keybindingscouldn't remember all important (for me) key strokes32 years ago all editors were quite hard to learn. Building Emacs was the harders thing back then.Debugging opaque error messages.Nothing specific, I think I’ve almost entirely had fun, even if there were difficulties.Custom configurations and custom packages were difficult figuring out. Also the ~/.emacs.d and sub-directories around that (~/.emacs.d/themes for example).It took time to learn the keybindings but the tutorial as a landing page was nice to start with.I started with Spacemacs (as my fingers were used to vim) which made switching far easier than I think it would have been had I just started with Vanilla emacs. Using evil-mode and knowing vim keybinds gave me a common "language" I could use to speak with emacs so that I could tell when it was/wasn't doing what I expected. Without the 'training wheels' spacemacs provided I don't know if I would have kept up w/ Emacs.Yes, I didn't know from where to start as I had little programming experience, and all the tutorial didn't emphasis on what they were doing, they were throwing package names that I didn't even know that these were package names. I was like trying to decrypt so unknown resource. I am still hoping to be able to write my own package someday.It is easy to hit the wrong keybinding and end up stuck in a menu that you can't get out ofIt took a while to "sink in", there's definitely a learning curve. Keybindings require getting used to, of course. And the configurability / extensibility does make things daunting initially.I was in grad school, enjoyed the challenge. Getting my .emacs org config dialed in the first time was challenging.Bad default theme and use if Ctrl key.I had problems in learning enough keyboard shortcuts to be productive. I had performace problems before I got native compilation working. Understanding buffers, frames, windows compared to traditional editor concepts. Emacs has its own vocabulary and modules are like islands compared to a very holistics editor. You have to learn the names and philosophies and verbs of different modules.Unique terminologyGetting productive in Emacs was really difficult, not just because of the keybindings but because I wanted modern text editing features like code navigation and completion.Quitting, maybe..? I honestly can't remember anything being ridiculously complicated. The documentation is very good, after all.Default keybindings which are unorthodox for modern programs is the biggest barrier, and still can be awkward when c-c from one program into c-y in Emacs for example. While the reverse might be c-x h in emacs into c-v in another program. Understanding elisp I think is another barrier. While not required, it is helpful, and there is an additional learning curve there.Many useful features and functions are not very discoverable. Learning how to program Emacs in a more complex way than just moving the cursor requires a lot of guessing and googling. The default Emacs configuration is also quite ugly and hard to use. The default completion framework and interface is confusing and hard to understand. While Emacs now comes with a lot of the tools required to make it a better experience out of the box, there's no way a new user would have any idea how to enable them without first watching a video or reading articles. I find this makes the on-boarding experience for people who are just trying it out and not too deeply invested yet very harsh.The vanilla keymappings was hard to memorize and to type. I switched to Vim for years, and switched back to Emacs after I discovered Evil.A lot to learn to start configuring it.Really difficult to understand value of REPL at the start. Also learning information architecture/conventions for where stuff is in Emacs.Keybindings and non-modalText movement being slightly different from macOS’s Emacs-esque text movement, which I used heavily. The kill ring.Learning how to extend and take control of EmacsLong time ago unfortunately. I don't recall anything specific.The keybindings. Also now, on a Mac, the Mac's keybindings override some of the Emacs keybindings.I learned to use emacs in a terminal in the 1990s. There was no menu to discover features like spell check or "indent region." If I hit the wrong key combination, I was often lost as to what I'd done and how to get out of it.I was fortunate enough to have my transition greatly simplified via a co-worker that got me hooked on emacs by showing me what all he could do in org-mode.Lots of key bindings. (And, where is the "Meta" key on my VT100?)It is hard to remember the key-binding; frequently need searching internet to find a solution for even simple problemHitting a key by mistake and being profoundly puzzled by the chaos it had done.I learned a lot from the Emacs tutorial and other places, but discovering and learning more has been sporadic after that. There is a lot to learn and everything is documented, but discoverability is the issue for me and I then again I'm mostly using Emacs to get stuff done. Learning spurts have been quite limited for me.Emacs requires investing oneself, it is time-intensive. It really is an editor for a lifetime. For people who just want to get a job done, it's too arcane.some package configsLearning keybindings, often having issues when I first started using the program in WSL when WSL was first coming outElisp was very different from what I was used to, and trying to "roll my own config" without understanding where to begin was tough.It took a while to get used to cut and paste.Modes derived from special-mode -- that keyboard-oriented way of operation was new to me at the time. Then finding and understanding the documentation: Usually, all of the answers I sought would turn out to be there, but only now that I understand how to look things up and am used to the way it's all organized can I find everything there directly.The weird commands. Getting help.Documentation was sparse, and the "emacs paradigm" was very different from other text editing alternatives. I now understand good reasons behind what then seemed willfully idiosyncratic, but it took a long while. These days the documentation is much better, and the general community is wider and more accessible.I must have attempted to 'learn' emacs 5 or 6 times through the startup tutorial. Took about a years worth of effort. The 2 features that finally made me 'stick' to emacs were 1) learning how to quickly switch to a buffer using the minibuffer buffer list 'C-x b' and how to get syntax highlighting for my Java homework 'M-x java-mode' (I think). Easily displaying all open files quickly with shortcuts convinced me that this was the app I could use as a workspace to manage a slew of files/projects/workspaces. The 2nd big difficulty was the *Info* pages. I found Info extremely difficult to navigate. The interface was completely foreign to any other software interface I had encountered, and it wasn't easy to 'jump' around to a node and then 'return' to a specific node. I still have that problem, but I just slog through it. Without blogs and example videos on youtube, I wouldn't have discovered 80% of what I have in my configuration. The "self documenting" part of emacs never felt like a big win for me due to the struggle to navigate that documentation. I suspect it's something that hasn't 'clicked' for me, and there is a wonderful way to integrate it into my workflow, but aside from C-h k/f/i I don't find it hard to reference.The keybindings were unusual (chording and which key does what) but now I love them The language of frames/windows/buffers is also very uncommon in modern usage.Finding and using the built in help, especially the navigation of Info files, was pretty hard. Discovering “describe something” was not intuitive. Key combinations where not clear at all. Finally the custom ”emacs” vocabulary for universally-known-differently operations made things even worst.Meta-X commands are difficult to learnI had no idea what this thing even could do and what to search for to find outDefaults are not very good. It takes time to learn how to customize. Some colleagues put me off using it saying it was too hard to set up.Whenever I met trouble, I couldn't figure out what was happening.Seemingly inconsistent behaviour when trying to exit mini-buffer, especially with the error "blip" noise was an early issue. Printer set up has been difficult when using Mac. As I use GNU/Linux personally but Windows / Mac at work, muscle-memory was an issue when going between them. Use of the "ALT" key causes issues and limits ability to use half-sized UK keyboards for without additional configuration. Key bindings conflict e.g. with OS shortcuts (such as "fullscreen" on MacOS).Keybindings and finding out how to configure Emacs.Some packages, installed together, were causing performance issues. As a beginner, it was a bit difficult to find out what is the problem and how to hack things together to make them work. I remember copying code from Doom Emacs's repo to fix something related to flycheck. I also remember experiencing high input latency in markdown-mode, and my "solution" was to remove some font-lock-keywords.Elisp was a barrier. Documentation was difficult to understand when elisp knowledge was poor.I tried to use it before knowing any programming, copypasting random bits and pieces into my config wasn't really great.to much stuffWithout the Doom Emacs starter pack Emacs looks and feels really roughFinding out which packages do the same thing and which of those is the most commonly used "default option" that is actively maintainedI had a hard time discovering new features, and learning Elisp as my first Lisp language was quite hard.I had many, but don't recall which.Maybe the huge difference in usability between vanilla and my configuration nowadays.Takes time to learnUnderstanding and writing .emacs was a bit challengingUgly, wierd bindingsStarting with zero knowledge on elisp and emacs, it was overwhelming to understand emacs from the start. Starting out with Doom, with its own way of adding and managing packages, put a lot of that confusion. I was lucky enough to have time to study a bit of elisp and configure my own vanilla emacs. The next hurdle was the amount of packages that are all over the place. I had to rely on communities, their discussion, and some decisions made by distributions (Doom, Spacemacs) to pick packages that suit my needs. I am two months in configuring my vanilla emacs, and it's performing the way I like it.Keybindings took a bit of time to learnI took sometime to realize that it was better to learn some elisp than copy some configuration from other folks without any elisp knowledge.What package I should use, for example helm or vertica, lsp-mode or eglotunderstanding elisp concepts, cons, lists, macros etc.... keybindingsIf you don't manage your extensions well, it might be bloated, and many packages may conflict with each otherKey bindings are really hard and frustrating to use for text editingThe competing emacs packages make it hard to tell what the right choice is. Also, dead packages are annoying.Initially, discoverability of features.Elisp has a learning curveFinding helpfinding keystrokes of known commandslearning the key bindingstoo many kindbindingsLearning of keyboard shortcuts and the inconsistency with respect to the Windows plattform. Steep learning curve.Key bindings. Coming from Vim, I used evil-mode for a long time.Hard to get used to standard key bindings, or remember the ones I have. Hard to trace issues to a specific package.Getting used to the keybindings, learning how to ask emacs questions about itself (eg describe-variable & co.), the other issues are issues with specific packages, like gnus.1. I thought it was just another piece of software (i.e. could glork its nuances/quirks just by usage). It took me over 15 years of usage, before I began to read the the Emacs Manual *systematically*: and that was a revelation. No one emphasized (or I was too ignorant to appreciate the advice) that reading the Manual would be a good investment of time.Keybindings for almost everything.Just getting around. Easy to forget basic things if not using it constantly. Initial lack of good vi key bindings. Vi was on every machine but emacs had to be installed and was huge (disk space) at the time. Also, frequently any documentation had a tendency to assume familiarity. RTFM is off putting. Arrogance is off putting. The whole emacs vs vi conflict was a waste. Once emacs got decent vi key binding support I used it all day every day. I don’t give a flying f*** about the merits of key chording. I just want to get s*** done. Focus on get s*** done and we’re good. Also, I use it now because I know I can still use it 30 years from now. Sublime text is great… vscode is great… intellij is great… but emacs in evil mode is eternal. Quote me on that.Learning the keybindings for navigation took time. I didn't understand Dired for a long time and found it frustrating to try doing simple things like renaming a file or navigating to a specific directory. And my config was extremely fragile and confusing before I switched to Spacemacs and committed to really learning elisp (I've since switched back to vanilla). Also, a lot of fragility in the config before using straight/use-package. Reliably repeatable builds are super important, and use-package makes organizing and isolating different parts of the config much nicer and more comprehensible.Years ago, when I started (no internet connection): -Difference between variables, functions (available or not in the minibuffer), faces. - Keybinding - Configuring even simple things was often not intuitive. Now, many people are sharing their knowledge and this help enormously to get start and to improve your own configuration.It's been too long. I'm sure I had some struggles. I believe I did the tutorial (C-h t).Keybindings, debugging startupDiscovering key bindings was very difficult. It was hard to see what's happening when status messages flash up temporarily in the minibuffer and then get replaced, making it very hard to debug or explain what was happening to try and fix something like connecting to a CIDER REPL. This was before I discovered the *Messages* buffer. This led to me just stopping and restarting Emacs multiple times. The syntax around alists and plists is still very confusing to me and I have to look up an example every time I want to edit a .dir-locals.el file.When I first dabbled in Emacs around 2013, I did the tutorial, learned some bindings, read a few sections of the manual, and started getting really excited about learning Emacs-Lisp. Then I tried to edit my config file. But nothing worked. Nothing I did would take effect. It took a lot of frustration before I realized that I was editing the wrong file. I think what happened was that I saved some settings through the Easy Customization interface, not realizing that this would *create* the config file at "~/.emacs". But I probably saw the "~/.emacs.d" directory and thought that it had to go in there as "init.el". But since there was already a ".emacs" file in my home directory, Emacs never loaded the "init.el" file. I can't say if that was the reason why it took several more years before I got interested in Emacs again. My memory is hazy, but that stands out.all those key bindingsIt's when trying to learn Emacs workflow of how things work, for example how Emacs automatically indent source code (as opposed to, Vi/Vim for example, where you have to manually indent code block yourself).Different terminology than vim. Complex architecture. Requires much more configuration than vim to be efficient. Starting with doom emacs from start is white complex.The standard key bindings are unlike any other editor I tried. I ended up settling on evil-mode to keep vim muscle memory, which made the transition easier, although it made things like the tutorial difficult. Not sure what to do about that, though. I have now gotten used to a lot of basic Emacs commands as well as their evil-mode counterparts. It's been worth it for me, but I can see why some might be concerned that it would not be worth it for them. Managing my config file was also a bit messy and confusing at first. I did not know best practices for organizing or managing packages. I ended up finding a config file of someone who managed their config with org mode.Mostly in getting used to the functional style of Elisp and configuration.Vanilla emacs there is no way for that to be learned when I first started using emacs. I was using the vim keys and was used to that and you open vanilla emacs and you hear about all the amazing features you can build onto it and it just felt a bit daunting on how to even get started. Had to use a starter pack until now and I now have the time to be able to start making my own config from scratch and personalising it massively.mostly learning the huge amount of shortcuts ...How to install packages using init.el config file. The correct way to modify key bindings. How to set a font using init.el config file.usual key bindings we’re very hard for me to learn. i felt like i didn’t know what was available and was overwhelmed by amount i needed to learn. spacemacs discoverability really helpedLearning basic keybindings, trying to use the unnecessary movement keybindings instead of arrow keys, it's painful to use if you don't map control to caps lock and will cause emacs pinky syndrome, did not discover key text editing features e.g. rectangles for yearsKeybindings are hard to learn when you use them infrequently.keybinding, learning elispGoing through the tutorial was a chore. Mickey's Mastering Emacs book really helped my understanding though.Basic navigation: opening and rearranging windows, maintaining order/arrangement of buffers, Emacs-style cursor movement. (I've been grateful to have "Windows-style" arrow-key movement but this has discouraged learning the Emacs movement commands.) Initial start-up with the help system: this is great for discovery later on, but at first is just another source of confusion as it assumes a basic understanding of key-sequences, Emacs nomenclature and conventions, and Elisp.Bad defaults, legacyDefault keybindings were hard to get used to. When starting to configure, it can be hard to work out which bits to keep from other people's configs. Not really knowing where Emacs ends and custom packages begin. Not learning packages fully.Elisp syntax is a bit arcanegetting various things to work, spell checking for example. Leaning key commands took a bitPackage download often fails.Special lingo used in the Emacs world about buffers and windows, point and so on. Not a big deal tho...Way too long ago, sorry.Default keybindings suuuucked!Can't recall anything in particularIt's special termsthe interface is completely alien to what a neophyte expects, so I didn’t know where I was editing, how, and how to exit. perhaps some adjustment to the first screen would suffice to help with that...Emacs back command (X + b) interfered with tmux's default prefix at first.defaults not beginner friendlyNo, but then, it was nearly 30 years ago.I remember hitting key combinations by mistake and not knowing how to quit from whatever was happening.Command Chords, general navigation, TRAMP is slow compared to VS Code remote SSHOverwhelming at first, likely due to the difference of what I was used to (though the same can be said for the switch to vim). Doom Emacs helped the transition quite a bit. Resources and guides were few and far between when I first started trying things out in Emacs.I had some troubles with system fonts having different heights, some things didn't work like i would like to but i was unable to tweak them by myself as I didn't have the elisp knowledge necessary. Sometimes it was just slow (TRAMP) but i think it got better lately but it could still be faster (Would really like to see multicore support).Configuring it is quite complex for newcomer. GUI lacks a lot functionality. Doom and spacemacs are great experienceI went overboard adding packages and had no clue what was going on when Emacs froze. The global mutability can be a bit much, when it comes at the expense of concurrency.The language used in Emacs is different than I was used to. M- and C- I often did typos on. There's a learning curve to almost every part of it and balancing learning vs. configuring was hard.Mostly getting used to the new key bindings and had some trouble defining my own key bindings due to confusion around minor / major mode concepts and elisp syntax.The amount of all feature to processLisp took me sometime to be more familiar with.Too much commands without knowing anyoneMuch of what was difficult surrounded acclimating myself to how things are done in Emacs versus other applications. There are few directly comparable applications that are themselves a full programming environment, language, and application platform rolled into one. Emacs masquerades as a simple text editor, but when you start taking a magnifying glass to it you begin to realize that it's far, far more than that. The process of learning that is what made Emacs difficult to learn. It's hard to know where to start, and how far it can really go. Even after a decade of very regular use I still feel like there are whole modules of the application I've never discovered or used to the fullest extent. The scale is often overwhelming to a novice.Package management. But that's gotten much, much better. The initial built-in tutorial was actually perfect.- Understanding Elisp - Change the vanilla look - Getting used to the keybindingsDiscovering keybinds and commands can be tough. apropos and various isearch integrations with M-x help (all that stuff where you can M-x and then start typing something and it gets fuzzy-searched in a minibuffer) but there's some commands that use language that at this point is antiquated and takes some getting used to, or just uses language slightly different from what you were thinking. Menus or icons might help here but I don't use them because, well, programmers don't make great UI/UX designers, and that's who makes the menus and icons in emacs. The big thing that's gotten better here is stuff like doom emacs unifying things and basically providing a distro that's coherent - their heavy use of hydras with minibuffer popups for each stage of the hydra makes it easier to figure stuff out.Terminology: (Frame, Window, Buffer, etc.) PerformancePerformance was quite slow and plugins would break between releases. This has improved somewhat recently. I'm not at all familiar with Emacs' keybindings, and while Evil mode is great, using "info" and related programs are confusing.Some keyboard shortcuts are weird. For example, VIM's hjkl for arrows is more sensible imho than emacs's defaults. Also use of Ctrl and hurting pinky.I expected that out-of-the-box experience is a good starting point. This was not true back then, and is even less true now. It took me years to realize how much I was missing. One really has to start with a good opinionated config, just to see what's out there, what the possibilities are.Strange keybingings (coming from dos/windows C-f seemed much more work than just pressing arrow left, but since I have learned to touchtype, I hate interrupting my workflow by moving my hands to the cursor block)Learning the oddities like a window is called a frame.Defining custom keybindings was especially confusing for me because I am mixing both Evil and a custom keyboard layout (bépo). I eventually found general.el and evil-collections to minimize the pain-points.Finding communities and seeking help. As a noobie at the beginning, don’t dare ask questionsDifficulty of learning and understanding its style of lisp. Poorly designed keybindings and difficulty remapping some obscure keys (like space, escape, C-g)Keybindings? Finding a good .emacs file to start from?As a Vimmer, I had heard about the editor wars and decided to give the more powerful editor a try. The defaults and terminology were unintuitive and archaic (not to mention ugly), so I had to do a lot of research (reading the entire manual, plus the elisp guide) before I could even start using vanilla Emacs. So I started with an Emacs distribution instead (Spacemacs). Eventually the lack of transparency with how to customise the distribution led me to learn vanilla Emacs and gimp my own version of Spacemacs without the heavy abstractions. I quickly learnt the importance of C-g to try to avoid Emacs freezing to death. Its stability could still be much improved (eg avoid blocking in main thread).The weird default behavior and UIMulticursorsIt was hard to remember some of the accords initially. I decided to re-bound some after.Oh, jeez. I think when I first used emacs, I was using in a terminal, and would hit Ctrl-Z to drop back to the shell, and then `kill %1`, because I hadn't figured out C-x C-cstrange jargons which are used in emacs differently to other editor/ide/... (electric, buffer, frame, ...)Had NO idea what was responsible for what. Packages everywhere, many of them with overlapping and unclear descriptions of what they did, or described in terms of other packages.the ancient keybindings, lisp syntax, the nomenclature ("buffer", "window" etc.)it was decades ago - can't remember difficultiesNo prior programming experienceWhat is all this dense yet verbose shite?Hard to find the right package or customization. Getting LSP to work.the defaults are not great, to be able to work on many languages efficiently, you must customize it.Learning to use movement beyond the arrow keysunderstanding the package managers ecosystem (straight.el now)- Keybindings that are standard across most other applications are different in Emacs. CUA mode and some custom keybindings solved this problem for me, but it was a barrier initially. - When I first opened Emacs, I expected an empty buffer in a text-oriented mode, not the Welcome Screen and/or the Scratch Buffer with its initial message- At first, opening and closing files were frustrating. I didn't know why I should open files without any file picker. I consider it a bad UX. - Lack of speed with other people's configurations was overwhelming. - MELPA.org is inaccessible in a sanctioned/censored country.The default key binding are horrific.Confusing terms, hard to configure easily, poor defaultsStarted learning Emacs in July '19. Spacemacs kinda sucked, so I went with Doom Emacs. Didn't really face any major issues, but I also did not know how efficient this program was. Emacs was a little slow back then though, it'd choke on 2k lines of org. Native-comp is pretty great but honestly I'd still like it to be faster (or maybe pray for time to eliminate the cruft from my config)Not knowing any elisp. I endlessly tried to get Casey Muratori's setup to work. In the end it worked, but I spent a lot of time on it. Time that I had at the time, but wouldn't have todayPackage conflictsEmacs default keybindings were difficult, good intro material also hard to find.Navigation throw and between files. Keybindings. Know what happened, what did I do? How to choose where the window opens. Understand elisp. Concentrate on english documentation. Where to start. I still face them. I just discovered the distribution emacs package comes without documentation.Learning lisp. Customizing themes. Emacs antiquated naming of buffers and windowsI kept calling commands I didn't want to call, like C-x C-c instead of just C-x, which is just cruel in some circumstances. On a German keyboard, some special characters are not as easily pushed, like backslashes. Since in the beginning I didn't configure my emacs as much and wanted to stay on the default configuration (same with keyboard layout), it really annoyed. To this day, I go the M-x route when doing regex-searches. Also knowing the names of functions I wanted to call was quite hard. Obviously, the "Emacs Pinky" was a problem, i.e. stretching the fingers to reach the far out Ctrl key for almost everything - until I found setting the tab key as an extra Control key. Which also had its disadvantages.elisp as configuration language, I had no scheme/lisp experience when I started with EmacsBefore moving from Atom to Sublime, I briefly tried Emacs, but gave up on how it was not "easy" or similar to Atom of most current text editors at the time. I did not realize that those "features" were the same ones that limited my use to just editing text. After getting frustrated with Sublime after paying the license fee and using the beta version 3 at the time, I finally looked at Emacs and Youtube was instrumental this time in making me decide to master Emacs rather than use it as a text editor replacement. In particular, Mike Zamansky's Using Emacs series laid out dozens of videos showing how he used Emacs in his workflow to teach and grade students. The Emacs Rocks videos were also nice, but they did not really show you how to do things. I would say it is important to show workflow use cases that Emacs can solve as a motivator to invest the time to master those areas of Emacs. The other difficulty is starting out with too many packages in the beginning, because that makes understanding what is built-in that much harder.Sometimes its slow when using heavier stuff like eglot with autocompletion although this might have to do with my laptop having a weak dual core then emacs The tutorial felt to bare bones it just provides enough to get you started and works well for that but i which there was some kind of interactive tutorial to show various features of emacsKey Bindings. Config being delicate and breaking frequently.Multiple ways to do everything. Debugging is incredibly hard to get right.Most of the stuff worked but they all had quirks. Indendation defaults for C++ was a bit weird, it didn't understand the new functionality (C++11 lambdas), IDE-like functions were working but not completely reliably (pre-LSP).Key bindings and the initial visual aspectkeyboard shortcuts differ from most gui editorsEverthingThe keybindings were hard to remember. But with some mastering, it feels so native.Yes. It took some time to get used to the basic navigation and editing key chords.Trying to customize a vanilla build without a starter kit was dauntingElisp configuration as learning new programming language.ELisp was kinda alian to me. I really wished there were other languages to configure emacs except Elisp but now I am a little comfortable but still having it would have been great. Like neovim provides both VimScript and Lua to configure it.It’s been so long ago that Emacs was a different beast in 1998zThe learning process of both the keybidings and configuration. The access to packages is not obvious.I think the most difficult things is how to customize Emacs to work smoothly for some popular programming languages.There is no standard established way to do many thing, too many choicesHaving used vim for a long time before emacs, it was a big barrier for me to switch to emacs keybindings, but I was able to bring my vim to emacs but in much better shape.No. It was "foreign," and adapting takes time—but that's much difficulty if one expects a good payback.key bindings, init.el configrolling a good, reasonable config on my own (with evil mode)- Binding Meta arrow keys with my terminal is a struggle from time to time - ELisp doc for emacs- elisp - Emacs being different from everything else (keyboard, naming things, kitchen sink apprach) - 2 decades ago there were no user-friendly websites with code snippets (ergoemacs, etc.) and the official/original documentation - although very detailed - is hard to get through. I still don't use it. Sometimes a 5 line piece of code serves a better purpose than 5 pages of docs. Same applies to man pages. - enormous ecosystem, "too much opinions and choices" - it was hard to understand what is what is Emacs, how to configure it (from fonts to behaviors) - there was no documentation on how to use Emacs when collaborating on projects; think: tabs vs spaces per language, smart tabs, save-excursion with whitespace cleanup and tabify/untabify, etc. It's not something everybody does, but when it's needed - Emacs can do it - one just needs to learn elisp which is a language one needs to be fully grown up to use.memorizing key bindings, they are still a problem for meLack of good tutorials and no simple tutorials for elispI was initially very turned off by the Emacs default GUI - it's just ugly. Making the default GUI look a little prettier would go a long way to making new people used to VS Code etc feel comfortable.Figuring out how to cancel things. Once I learned to hit C-g instead of escape things got better. Most keyboards have a poorly placed control key though so rebinding caps lock to control helped a lot tooOne Im currently facing is learning elisp, not for it's difficulty but because i have little time to dive into itNon standard keybindingsA long learning curve, in part because I learned randomly and gradually, not systematicallyDiscovering Shortcuts, Remembering Shortcuts, Discovering useful and easy workflows.Where to find the information (like where to find help or how to do something), the keybindings were not straightforward to learn (like how to copy/paste, or how to call a specific command), how to configure Emacs and how to use Elisp is still a mystery to me.It takes a moment before the default mappings become muscle memory. Unawareness of IDO, FIDO and vertical completion frameworks led to a significantly slower and less fluid experience with Emacs than what was actually available even when I started using it.30 years ago ? None that I can recall.complicated key binding. difficult customizing, high degree of freedom for novice.Cursor state is not independent of scroll position (I still find this problematic, despite the mark ring) Unergonomic default configuration of completing read which does not provide enough affordances for available options (vertico solves this nicely) Many many commands to learn, many of which differ from “mainstream” editors. Of course now I think in most cases the emacs versions are more ergonomic but this was a stumbling block at the beginning. Interaction between desktop environment pasteboard and emacs kill ring can cause data loss Help files rendered in monospaced fonts which is difficult to read compared to proportional fonts. Using proportional fonts causes poor ragged edges due to manual line wrappingThe self documenting features are not evident to a new user. All the ways to get help went unused for a long time.different key shortcutsLack of tutorials to set it up quickly.Using on windows without ssh and other issues that just work on Linux. I use exclusively on Linux now.There is a lot of specific nomenclature to learn.My primary use for Emacs is life management, so I make a lot of use of the task management features of org mode. The biggest difficulty I faced was the problem of the blank page: because you can set it up in any way you like, you do need to know what you're trying to build before you start to build it. I suspect had I tried Emacs 10-15 years ago I'd've bailed as I didn't really know what I was looking for in a task management system. But 2 years ago I'd tried enough apps that I had an idea of what was right/wrong with each. Actual difficulties learning how to do things were few or non-existent, I was braced for the "very steep learning curve" I'd read about and then was pleasantly surprised how the tutorial and documentation got me up to speed very quickly.elisp sucks! Would be great to introduce interfaces to other languages such as python or lua.I tried 3 times to pick up emacs, remembering the shortcuts we difficult at the beginning, then just like how starting with linux is, there were a lot of problem with packages: conflicts, configuring was difficult (or more accurately I didn't know how to).Hierarchy of action commandsYes - even basic editing operations were a mystery. Nothing made sense until I managed to open the Texinfo manual. Ah, youth...The keybindings were difficult to understand at first. After that I struggled to understand how to use the self-documenting features of Emacs. The bindings seemed obscure and I wasn't sure of which ones to use for the right tasks.Very few, Spacemacs & in particular the built-in menus when you hit `space` are extremely easy to learn for a vimmer.- (Not a difficulty:) The Emacs tutorial was very helpful. - I *still* have never tried to understand the the different types of kill/copy buffers. - I never managed to use the the info-nodes documentation well and have found it confusing when I see it mentioned in forums. - Learning the nomenclature in order to be able to search online for features or ask for help. - Some features can be hard to discover naturally.Using e.g. Google to learn stuff lead to confusion. Reading the manual helpedThere is so much that is possible to configure but configuring specific things can often be difficult. Some language integrations are difficult to add. In sum, configuring emacs can be very bewildering.Shortcuts and text navigation Vanilla emacs is a bit ugly1. I was frustrated by the defaults; I found them even worse than Vim. Also, the set of included packages is bizarre to me: Emacs comes with a chatbot, Tetris, and multiple (!) IRC clients, but not with a completion popup, ido/ivy/helm, which-key, indent guides, smart-tabs support, or a major mode for TOML, YAML, or Windows batch files. 2. While I generally like Elisp, I found it a big downgrade from Python in some ways. The biggest one is that everything is done with lists and vectors instead of abstracted data types (tuple, ordered map, unordered map, set, multiset, priority queue). In the same vein, there are multiple associative data structures in common use and every single one is unergonomic in some way.Started with Spacemacs to use Org Mode, but it is not Emacs so I got lost completely. Then went to IDEA for Scala development, then to VS Code for Go development and finally back to Emacs after churn from VS Code updates that break my editor. It’s hard due to totally different concepts/naming and so many details on everything related to text that other editors nowhere near. Some useful keybindings are hard to learn and type, especially C-M-…write init fileLearning Emacs LispOdd unusual key bindingshaving to copy a lot of code without understanding them/ well written elisp tend to be hard to understandkeybindings were hardnavigate help pagememorizing and typing all the special key combinationsIt was very early in my career so I didn't have many bad habits to breakJust the keybindings, but it hasn't been a huge deal and I've learned to context switch.Emacs key bindingsThe one thing I strongly dislike are the standard keybindings, but thanks to Evil I don't need to worry about them. I've also had updates break my setup numerous times, but this hasn't been an issue with Doom, since the versions are pinned.It has its own way of doing things, which makes reading the manual important, which is unusual nowadays. It took me a while to understand that all is just text, that something like Dired is a mini-app but really behaves/works through text, and so I shouldn't expect it to be impossible to change the text or break it or for hooks based on text editing (same goes for Org e.g. updating clock tables) to react immediately without running something. The idea that it is so introspective and reading function documentation can explain most things. Most of this makes sense after going through the manual (which I still haven't done to completion -- far from it). That the greatest value of it comes from customizing it.Arcane user interface with too many keybindingsI use emacs in MS Windows (work) and some packages doesn't work super-perfect like in Linux, because in MS Windows doesn't work very well with external commands - for example magit is very slow in windows, the git clients (e.g. git-extension) are faster.It has a long learning curve. There is no getting around the fact that it's terminology and base key-bindings are completely unintuitive to new users.Understand configs found from Internet.Learning the keybindings. Finding ways of changing the config to fit my needs.Figuring out keybindings and buffersMissing documentation regarding load paths, non-searchable documentation for Elisp and Emacs in general, made it hard to get things working.It's really rough to get in, even being a programmer. What we would need is to have a Doom Emacs with very good resources for beginners and an easy path for proficiency. In the current state and because of the extreme flexibility (=> lack of consistency) getting to know Emacs is just too difficult for 99% of people, even if they have the inclination to do so at the beginning.getting used to standard keybindings, not remembering my custom keybindings. Difficulty tracing source of init errors to specific packages or config mistakes.Elisp differences from Common Lisp. Lack of learning resources.There is so much depth to Emacs that it can be hard to figure out how to do everything well. Simply editing a file is easy enough, and you can figure out the keybindings eventually. But then you want to start doing more complicated things and you have to invest time into doing all of them. I've kind of set up projectile, for example, but I've never really figured out how to use it effectively and mostly use it to close all of the buffers that I open when working on a particular project. The same is true of Flycheck and lsp-mode/eglot, which are tools that I think would make my life easier, but which have an activation energy that I am not always willing to put into my text editor.Learning how to install Emacs was the hardest part.Hard to know how to get started, many ways to do the same thing (which package do I use?)The internal mechanisms, and elispPre-doom, it was hard to get a curated experience.I ran my own Emacs before using Spacemacs. Not having a strong starter configuration and all the possible ways to customize it without some best practices was difficult for me to wrap my head around.It's been a very long time; I can't remember anything at this point, but I don't know how much I'd trust that. :-)The key bindings were, back then in the 1970's, a new thing; but a good improvement over TECO.elisp learningKeybindings, finding examples of how to do something (eg. a clear way for a newbie to install a Python development environment)Emacs pinkyToo much knowledge needs to learn. I need to know the basic knowledge of this tool, and learn elisp, and read other programmers' settings to know how it works.The default bindings are uncomfortable and obtuse, I replace them with evil binds as soon as possible.Mapping my brain and body to use the keybindings and paradigms. Furthermore learning lisp is different than most procedural languages I am used to.Packages based around LSP stuff seemed to trip me up a lot due to outdated info or external dependenciesOut of the box experience was not the greatest, felt and looked old-fashioned. Coming from vim the emacs keybindings also weren't intuitive at first.elisp was unfamiliarBad Starter Guides, Hard Introduction, No "vimturot"Steep learning curve, elispI think default keybindings were the biggest obstaclesThe default configuration and the default looks really put me off. It still requires considerable config you make Emacs decent for day to day work.elisp programming logicdifficulty in getting an overview of what is possible in emacs and how to achieve itThere was a lot of information and it took several days to comprehend it completelyAwkward default keybindings, Awkward terminology for common actionsI still do not understand the elisp programming model.just a lot to take in at very start, key bindingsYes lots, for the first few years, I could barely do more than write text. So strange compared to other things. In comparison, I used mathematica at the time, and found that editor very easy to learn.I started on Emacs 19 or so on Windows back in 1999. The built-in documentation was not new user friendly. Too much Lisp which I had very little experience with at the time. I ended up buying an O'Reilly Book to get even the basics. Searching the internet in the late 1990's was painful and I would often end up more confused than before. I stuck with basic Emacs and have ever since because of that.elisp, config management, maintaining personal configuration is like a full-time jobI cannot, but recently my team had a developer attempt to learn Emacs to work on our Clojure code-base and he found it very difficult. His particular pain points were around Emacs not matching the UI conventions he was used to, and him not being experienced enough to know how to change Emacs to behave how we wanted. He is a very skilled developer, but the default Emacs experience was a real barrier for him.Configuration has a steep learning curveelisp, namespacing, key bindingsSetting up your configuration the first time can be very daunting.Configuring emacs. Without using something like Doom Emacs, making it anything close to useable is basically impossible even after a good amount of hours reading the manuals and searching for snippets on the web.Learning to conf the init.el without having a good knowledge of programming, and integrating with other projects (like pandoc for convert to PDF) for a good workflowEverything was pretty smooth, except the cut, copy and paste keybindings annoyed me a little for the first few days.It's not straightforward to configure melpa, which was mandatory to get evil workingSetting up the environmentInit file organisation, occasionally a kind of 'lost feeling' where I didn't know what to do or what I even wanted to do.It is hard to say, but I was probably a bit overwhelmed by the amount of functionality.There's no way I was going to use it without a configuration framework because of the complexity. Doom really fixed a lot of that. I'd tried Spacemacs and it was a bit too slow.Not familiar with key binding.Nothing out of the ordinary.The problem is, it's an investment. It's a bit like learning a new keyboard layout - it starts off incredibly slow, and you can do even less than you could before, with far more mental effort. It requires persistence to reach a point where it becomes equivalent in effort, and then, depending on your preferences, it seems easier - the problem is reaching that point. If you've never used something like emacs, you don't know what the possibilities are, and you don't even know why those possibilities are such a nice thing. Configuration? So what? I can already enable dark mode in ! So, part of the problem is likely that, for new users, what even are their preferences? Also, the default binds are... Begging to introduce you to CTS.Besides learning the keybindings I struggled with the UI parts and the overwhelming possibilities. But unfortunately these are now in my view the absolute strengths of emacs.Mostly lack of community, everyone was using Turbo Pascal and EDIT/TPU (on VMS).It's been too long.Managing windows and removing automatically created onesKeybindings were a bit unusual, the tutorial was good, but very long. As a beginner I faced many problems, like some elisp error I had no clue about.Remembering the keybindings. I found the tutorial very, very good.The default UI was kind of hard to navigate at first (vanilla Emacs). Extending Emacs with Elisp was also hard as it requires the knowledge of how Emacs is structured.- the evil binds; - find the correct packages for my needs; - the doom config for my needs;Understanding the buffers idea.Some text configuration.Getting used to new shortcuts used for text editing actions (copy, cut, paste, etc) took some time.The disconnect with cursor movement and the way I was used to that working was a challenge. Also I didn't know about all of the ways emacs could help me discover things or learn new modes contextually (like how you can hit ? during chords to list where you can go from there)Keyboard bindingsSpacemacs helped, but the learning curve is just incredibly steep.I don't think I had any serious difficulties.I didn't spend enough time learning the basics and spent too much time trying to tweak the packages and thus the keybindings.It take some time to understand Emacs's concept like frame, buffer, window. Also Emacs Lisp.Multiple packages for the same thing, mostly built-in vs third-party packages are confusing. Especially because Emacs is that old it is possible to find old statements that are not longer true: "flycheck is much better then flymake, projectile over project.el" etc.Relearning the key bindings which were significantly different from the "typical" editor (my default instinct was to use C-c and C-v for copy-paste). Also the default "box" cursor instead of a "bar" cursor has a very intimidating effect on beginners.Don't remember, adding packages maybe.Evil funkiness, poor performance on W32, clunkiness of big packages like haskell-modeUnusual default settingsKeybindings can be hard to remember et times.The default keybinds really threw me off. Debugging seemed like a pain (and I still have not gotten around to a good workflow for that). Emacs packages did not work out of the box (TLS errors). I did not see the value of text based interfaces initially too. I was using more GUI focused apps like Google Calendar, I thought EWW was dumb, and why did Emacs include Tetris?I can't.Key combinations and configuration as it is confusing and definitely the buffers !!!The default key bindings are torturous, and I honestly suspect vim has a better model for them, but only under the constraint of popular keyboard layouts. I very early made sure to move Ctrl, Meta et al to home row (https://axelsvensson.com/keyboa/) and have never looked back.elisp configuration, key shortcutelisp or lisp in general, but I love it nowLearning curve was challenging, because the concept of a text-based interface and Free approaches to software were new to meWeird keybindings!Billions and billions of commands.The keybindings were weird to get used to - particularly the movement keys - and figuring out what version of emacs to use was a challenge. Both in terms of configurations and release - it wasn't clear what the benefits to doom or spacemacs were compared to vanilla emacs, and especially on Linux Mint it was an absolute pain to get emacs 28.1. I haven't tried since the summer, but the difficulty in getting the latest version of emacs on Linux vs the complete ease of downloading up-to-date packages on Windows was a surreal experience, especially for such a free software figurehead project. I'm not interested in building emacs from scratch.the critical mass of things you need to know to get the most out of Emacs is enormousNon-standard keyboard shortcuts (e.g. Ctrl-V doesn't paste, Home doesn't go to beginning of line, etc)Learning curve is large. The basic tutorial sets things up nicely and explains the basic concepts but the only way to learn how to use it is to have a specific use case that forces you to spend the time. Many of the concepts (frames, buffers, killing, yanking) are unfamiliar in today's world.It's terribly complex. Many features are explained poorly or not explained at all, so they're hard to find and hard to learn. The documentation often seems to be intended for people who already know how to use it in the first place. It has strange naming conventions that don't make the most linguistic sense and aren't used by any other computer programs. Often the basics aren't even set up so it takes some time to get it useable (sane defaults that the majority of users would want).Emacs lisp was hard to get initiallyNo default support for arrow keys in terminals circa 1991elisp (I still don't know it). performance issues. crashes. terminology (minibuffer, ...)Default configuration is hard to use, Documentation is too long, Mouse bindings are unlike any other program, The completion at point is a bit unintuitive so I had to use other things like company and ivy- one thing important to me seems to be unsolvable at all: I would like to have cursor "(point)" stay at a constant position in the document (even outside visible area if needed) during mouse wheel scrolling, just like in any modern GUI text editorGetting anything to work on my Windows machine, which I'm forced to use at work, is a nightmare. In particular, trying to use magit, which works so seamlessly on UNIX, is awful.Initial setupKeybindings. Terminology (learning curve). Tracking down weird side effects I'm not sure the cause of (I've got directories littered with files named 1 for some reason)Different key bindingsFiguring out where to go for online docs, figuring out how to use the built-in docs.Default keybinding are awful. Difficult to setup for the first time.There are so many parts that often work differently from each other, it was hard to find out what's important for me.Shortcuts are very different.Mostly, getting used to the key bindings. For the longest time, I only used vanilla emacs for writing prose, not knowing just how many packages are available.Keybindings and general programming modelThe keybindings were hardest for sure, I leaned heavily on what I could do with the mouse at first although I don't do that nowLearning shortcuts and commands, trying to make a decent IDE-like environmentlooked poor default. I needed to know key bindings, introduce plugins, and tweat configurations by elisp. But be aware it was over 20 years ago...elisp, hard to know which packages do whatIt was not easy for beginner programmer at first. The way how Emacs intenral works was not clear. use-package kept that obscured for a long time. Without prior lisp experience the beginning was not very enjoyable. The resources on learning Elisp were limited, and mostly adressed to people with better programming background.Theming1. I didn't know Elisp 2. Default keybindings are quite exotic compared to other editors 3. UI and default look and feel are far behind modern standards, need to work on configuration a lot to get to something acceptableI learned it in the early years, where getting the terminal configuration right was a pain (not binding backspace to Help, and not having search bound to XON, and making VT100 arrow keys do the right thing).Often struggled trying to understand the errors, for example 'end of file during parsing' could be very clear if you are familiar, but a little extra words like 'you may have an unbalanced parentheses', i think, would be very helpful. Additionally while Emacs is self documenting, the docstrings of some(many) of the functions could go a long way if they included direct examples instead of the syntax.Coming from VIM it's quite different, Elisp was difficult to learn if you were tough only 'C' derived languagesAll things lispElisp can be hard at first, and it is pretty much compulsory for anything beyond basic configuration.By starting off with frameworks, I didn’t really learn how Emacs works. David Wilson’s Emacs from scratch was what I needed and I’m a much happier Emacs user now!Confusing structureTended to manually confuse C-i C-j with C-i j that is, when to let up on the shift/control/meta key1. Very hard to remember key-bindings 2. Hard to look for help online unless you know Emacs terminology 3. Assumes a knowledge of Emacs LispThe wiki is often obtuse as a beginner and sometimes references outdated packages. I found difficulty understanding things like keymaps and package repositories.Key bindingHard to learn keybindings, mitigated by used of evil mode. Initially, non-modal nature was jarring after 20+ years with Vi(m).Configuration and the default look is really ugly and deterring. And of course one has to learn the key bindings…For the most difficult thing to learn about emacs was elisp.It was hard too learn which advises from various sources to follow.Yes, customization is complex even when i was using doom emacs. Start configure in config.el, or in vanilla emacs emacs.el, at the beginning was confused to me. Install packages also dificult for people don't know anything about elisp, i mean, all packages need some customization and some times that customization is confusing, like call hooks or defining variables with setq or set, is something that is not clear the first time.No documentation.Not understanding that it's not just an editor.Understanding Elisp (often get lost in the huge documentation while the core components are quite simple). Slow startup time (as newbie, I didn't understood how Emacs evaluates the init.el, I didn't take advantage of autoloads, deferred loading...) Usage of frameworks (Doom, Spacemacs, which lowers the entry level while lowering also the understanding of Emacs' internals).I don't remember. I guess key bindings where overwhelming. Back then, entering ed by accident was way worse...hard to run elisp.many keys, uglyTerminology.Getting used to the keybindings took commitment and time. Finding the packages I now rely on (such as lsp-mode, magit, etc.) was just through word of mouth, so this took me a long time and I had a reduced experience until then.The unusual keybindingsThe amount of configuration and research I had to do for setting up fonts; some outdated/irrelevant results (I didn't take into account whether to include doom emacs in my results) made me set up fonts in a way that worked, but more inefficient than it had to be. Some obscure errors relating to upgrading doom emacs, and installing packages in a way doom didn't like at all. And the performance/stuttering, it's better now, but it would've been nice if I researched about native-comp and compiling packages beforehand.No starter kits back then.I went in expecting a somewhat steep learning curve, so I wouldn't call them difficulties, it was just learning. But unfamiliar it was. Then again, there was the built-in tutorial.I started with `C-h t`, I think the biggest hurdle was unlearning CUA instincts in favor of Emacs' own key bindings. I started using Emacs starter kits (specifically Emacs Prelude) until I understood enough to write my own configuration. I think probably the biggest helps were the `which-key` package along with a genuine desire to learn the system (as opposed to passively picking it up). The learning curve was certainly steeper than more commercial text editors (e.g. VS Code, JetBrains products) but I was strongly motivated to learn Emacs after learning about VS Code's troubling telemetry and monetization practices.Knowing where to start after the tutorial. I wanted to start from scratch, but also wanted to get work done. Starter kits like spacemacs and doom helped, but they also made emacs harder to extend, debug, and craft into what I wanted. If a "layer" existed that gave me 70% of what I wanted, I limped along while feeling I made an economical decision. The problem is this robs you of emacs greatest strength in molding an environment 100% for you.Honestly probably short cuts for less used modessetting up the config file to my needs took a lot of time, but once it's done it works like a charmremembering key bindingspackages come with conflicting keybindings, customize keybinding not optimized for all cases, also have to change and the forgotLack of documentation for some packages, lack of beginner tutorial (book Mastering Emacs helped a lot there)Debugginginit.el bankruptcy; locking/freezing especially with comint-modes/shells and long linesYou have to craft your own configuration of emacs over a long period of time until it is usable on the same level vscode is.distinguishing whether the problem encountered is solvableElisp has a learning curve but can be overcome with some readingI think dir-locals were explained in a bit of a confusing way, following that, there's no obvious way to figure out which variables to tweak between different modes for basic-offset for instance, or if they even exist. One thing I was a little surprised by was lack of built-in modes for Autoconf, Bison, Flex and Go.elisp, lack of common-to-the-world vocabularyLearning anything about elisp & common lisp. There didn't seem to be a call to action to play with your init.el configuration file. And lack of small tutorials/examples of what you can add to your init.el . In my opinion needs a "quick getting started" for init.el .Not really, though I started with reading most of the manualHard to fix errorsI started using Emacs because of org-mode, and I found the Org documentation hard to understand without prior Emacs knowledge. If there were a special Emacs experience setup for Org usage, it would help beginners a lot.The biggest struggle was not knowing what exactly I had just typed (by accident), what it did, and how to undo it. That constant fear of "messing something up" was the main thing that I didn't like as I was learning.The documentation for EMACS itself is great. The documentation for packages is often poor.Learning keybindings. I printed a cheatsheet and forced myself to use emacs for a week.Initial learning curve of lisplack of great quick start videos, I accidentally found one really good and it was my entering ticket into the emacs worldHard to debug errrorsMany Emacs tutorials suggested installing some external packages to improve the functionality. However, all of them gave different instructions, using 'package-install,' 'use-package,' etc... It took me quite a while to understand what all of those meant and figure out the optimal way.emacs keybinds were so different from what i was used to in vscode and other common editorsnot aware of / forgetting about C-gKeybindings are a bit odd for first time users. But once you understand the logic behind them, they are fairly simple.The default settings and keybindings are awful compared to more contemporary editors.Many keychords to remember, and some odd terminology like "kill" and "yank" instead of cut and paste.I learned it incrementally over years. I suppose if you tried to do all of it at once--that would be a huge challenge. Compared to modern code editors it seems less approachable but the payoff is higher.Different way of referring to things like buffer, window & frame, compared to other popular programs.different names for various things (buffer, frame, window, yank, kill)The keybindings are decidedly non-intuitive.accidentally pressing the wrong keybinding and getting into a really confusing stateKey bindConfiguring Emacs and the it's packagesFinding support for different programming languagesThere are some footguns, especially with performance. It's easy to install a package, or copy-paste code from the internet, and end up with an extremely slow setup. Also, there is a lot of legacy cruft. As a fresh starter, there was a lot of "flymake or flycheck? display-line-numbers-mode or linum-mode? line-numbers-mode?"Elisp was another hurdle to conquer. I still don't understand all of the internals of Emacs but I can configure most of what I want. The configuration process can be a tedious trial and error process.Tutorial was a slow read and Emacs wasn't as ubiquitous as vim for all machinesThe default emacs key bindingsTo have the correct mindset in order to properly navigate with the keyboardKeybindings. Learning elisp to customize my setup.Undeniably, it requires some initial learning effort, e.g. one has to learn some keybindings and in order for things to be customised one often needs to write (or copy) some Elisp. That said, I don't think the initial learning curve is necessarily a bad thing and I'm not sure re how much that can be removed or mitigated.Bespoke terminology and interactions, fragmented packaging.I had trouble with the default key-bindings (no ctrl-c / ctrl-v) and the names of concepts was strange (yank, kill, window…)I found the buffers and windows difference surprisingly confusing. I also struggled to troubleshoot errors when things went wrong - if everything was purring along nicely, I had little to no issues. When something wasn’t working right, I frequently struggled to find help or to understand the help I was given.Debugging the config file in general can be tricky when you don't know emacs-lisp very well. The error statements are hard to follow.Had to do extreme amounts of customization to make it do all the simple stuff most CUA editors do. Missing too many features that should be stock.At first, I was confused what emacs was supposed to be. A text editor but not really a text editor? Learning Lisp was challenging initially.Lisp wasn’t my cup of tea. I wasn’t a programmer when I started and learned elisp along with python and I kept thinking why tf is elisp so convoluted. I no longer think so. Lisps are coolTutorial took good care of these things.Lack of friendly documentation. No user-friendly way to give a user glimpse of the possibilities.Default keybindings are kind of wild. I really wanted the customization to be more integrated. I think the customization stuff is awesome, and it makes emacs feel even more introspectible and customizable. I think if more work was done on organizing the elisp output of customize that could be really really cool.i was extremely slow the first days and weeks of switching to emacsInitially the keybindings were definitely confusing, I think I used the menu-bar a lot. I just was not used to the interface, and didn't navigate the tutorial correctly because I thought I wouldn't need it. However I have come to love the default keybindings.Coming from vim i did not understand how every key you press calls a lisp function. When that became clear it was far more intuitive to extend it.Elisp was a shock at first, little knowledge of the breadth of what I could customize, took a while to make a best-practices conf file.It was too long ago.Yes as I'm still struggling. I have a lot of trouble with E-lisp. It is hard to learn and is confusing compared to python and C++ which are the two languages I'm familiar with. I understand that there are a lot of advantages, but given my profession is well outside programming, it is hard to learn a totally different paradigm in order to get the editor to do what I want it to do. Sometimes I end up just going back to visual studio code because it's easier even if I can't get it to do all the things I want it to doThe configuration was the hardest part. Adding functionality without breaking the world in the process or spending untold hours figuring out how to do it was probably the most frustrating part of learning Emacs. I kept leaving in frustration and coming back later. That situation has improved greatly over the years, especially with "porcelain" like DOOM.It was frustrating to discover my laziness and unwillingness to read the user manual and all the problems that caused.Developing new muscle memory Letting go of ways I used to do things and instead do it the Emacs wayFrames vs windows vs buffers.Terminology (confusing), documentation for internals (i.e, built-in functions/variables aren't listed in the manual, can't use something if you can't find out it exists)Learning the UI which is not like other editors I had used (example: the minibuffer is not a thing in many editors)Didn't understand the notation for keybinds, e.g. M-xthe kill ringGetting stuck after pressing a wrong key. I would hit ctrl g a lot.bad defaults, no good default configLong Learn curveThere were some, but it was a very, very long time ago and I can't recall.The key bindings take some time to get used to, but once they've been mastered it's then easy to learn more and more. Configuration is a steep learning curve until you get the hang of the ways in which packages work.it was very easier than vim, honestly.Elisp. Obscure terminology. Strange keybindings. Poor Windows support. Requires lots of packages and configuration to be really useful.Hard to adapt if you don't know lispI started with doom, which made it hard to figure out how anything works.Getting started was tough - tutorials were not friendly to 0-knowledge 0-experience users.No difficulties, but it took a lot of time.Leaving neovim way of doing things took some time to adjust. It also was my first experience writing any lisp codeAside from getting habituated to the keybindings, understanding configuration was very confusing to me. I feel like I am still quite confused, but I make far fewer mistakes now.Keybindings are hard to learn.🤔Just getting used to navigating around and general discovery.I still don't know how to use the help system. It's also difficult to lookup definitions for various bits of jargon on can encounter (mostly elisp/configuration related).Unfamiliar default keybindingsThis is also true today: lots of tutorials that I find online don't work out of the box - package doesn't exist, or keybindings don't work.that was a long time ago.Not really. Although from the perspective of time, I kind of regret starting with Evil - hoping for more smooth transition from Vim, which in reality turned out to be quite frustrating and detrimental. I sould have just jump straight into Emacs' way of doing things, without any such crutches.The difficulty of setting up packages.My programming skills were also very primitive so, I had difficult time getting along with elispConfiguration is not obviousIn my first time, I installed the emacs flatpak package, which make difficult to recognize my PATHsThe manual was hard to get into, and video guides were either old and didn't match the current emacs version, or my particular emacs distribution (doom emacs). This has improved massively in the last 2 years, IMO.Learn elispDebugging things when bad elisp I wrote didn't work as expectedelisp. I'm not a programmer, so elisp is my first program language.It was slowCompletion and indentation did not work easily.Things are not easy - it takes time/effort to get to a point where things are customized to your liking and you don't have to restart emacs because it has gone into a undesirable state (not hanged/crashed, just that you eval'ed some elisp and now have no idea how to undo it). That there are multiple ways to do something is a strength, but it can be a blocker when you want to do something.lack of "one source of knowledge"Debugging memory usage (resources shown by memory-report and garbage collector do not reflect actual usage). Difficulty with introspection of environment variables used by Emacs (I had a very hard time getting LSP to work with Typescript, Csharp and Python because of that)Emacs is very big. There are as many ways to do things as responses on Stackoverflow, so you never know if you're doing things "the right way" or if it's just a hack. I see now that there's no real "right way" to do things, but it confused me as a beginner, and left me scared of trying things. The big fragmentation in setups/config styles causes a lot of confusion when reading solutions on SO. Someone will say "call X function and blahblah" and X will not be defined, and I'm left to wonder if it's because Spacemacs doesn't have X, or if it's because I haven't enabled something else, or whatever.The keybindings took some getting used to and generally understanding how things work in emacs.keybindings we're unintuitiveNot understanding hooks and adviceinstalling it on windows was a pain and performance on windows was badNot having guide-key built in by default.Memorizing key mapsWanting to make it similar to mainstream idea of text editors (e.g: sidebar for files navigation on the left, outline navigation, bottom bar with words count, buffers = files, tabs, right click context menu, copy/paste, undo/redo, welcome screen with shortcuts) and more integrated with the OS (fonts, theme)I didn't even touch elisp for the first 6 years or so. I needed to write a thesis in LaTeX and came across Aquamacs as one of the suggested editors. Didn't even really know I used Emacs. I should've looked at Elisp from the very beginning which would've prevented many misdirections in using / configuring emacs. I now am happy with a as-minimal-as-possible DOOM layer underneath my personal config because doom core has many batteries included.Muscle memory from using vimEmacs is complicated, and its bad when you dont really know elisp. Learning elisp fixed thatlisp, documentation, lifecycles, concepts / keywordsTerminology, what to search for on web when I wanted somethingUnderstanding the full scope of what I need to learn (modes, hooks, Elisp machine, etc.). In short, having a roadmapLISP is hard for me to read (parentheses are tough for me to visually parse); Emacs GUI is out of date (doesn't resemble any GUI I use); Emacs documentation almost requires a separate book or volume because built-in support is tough to access and refer to;Keybindings are not intuitive, lots of things to know before actually be decently capable of doing thingsBecause it is so large and complex, I had difficulty finding information about how to use it. Bear in mind, back then. My main source of community feedback was net news and relay chatIt was hard to discover features that I was used to from vimUnderstanding what workflow suits best for each situationconfigure a basic system- alien keybindingsI started off by using doom emacs, and I had some difficulty getting started since I didn’t manage to find nice doom relevalnt help, and was using a lot of general emacs tutorials which weren’t suitable for a doom environment. Also it can be very difficult to diagnose what’s wrong with a package, even now there a bunch of papercuts that I experience that I really have no idea how to diagnose so I just restart emacs or the mode im having trouble with.I made the mistake of trying vim on Slackware back in 1998. Lucky for me the Slackware book & CD came with tons of cool stuff to try, one of them was emacs. If i remember there was a short chapter on emacs, but after taking the emacs tutorial, I have never looked back.I struggled until I found Spacemacs. That made my out-of-box experience much better.It took me 2 attempts of learning Emacs. First one failed, second one I took more time to find out what all the fuss was about. I remember looking up how to even save a file, because of unusual key bindings. And I did want to learn normal Emacs, not some other version, that might not be the real thing or so. But I forced myself to learn the shortcuts and a bit later adapted some of them to my needs. Slowly adding config in my init.el and all that. Sometimes my config still changes, but it does not grow much any longer.1) TLDR 2) My experience 3) My recommandation to start configuring emacs from scratch TLDR Emacs does not work great out of the box, many unusual key bindings and concepts (Buffers, lisp) slow down the initial learning phase, lots of things to learn, many essential tricks to build emacs need to be found outside of the official doc, takes time before reaching feature parity with intuitive editors (like vscode) MY EXPERIENCE Emacs has unusual bindings and a lot of things to learn. I started on a vanilla config and had to start configuring emacs from another editor for a few days until it became usable enough to finally switch. And even then, I was missing many important things such as a decent debugger and lsp-mode/eglot. Past that point, I still had to look for many resources as I had to look everywhere (official doc, blogs, melpa, git, reddit) on internet to figure out all the things I could do to extend emacs. STARTER KIT FOR VANILLA EMACS: I consider that any person starting from vanilla emacs should read Mastering Emacs (M. Peterson) before installing the following tools that I consider as essential to begin extending the editor: a theme (dark), a package to show available M-x functions (such as smex), use-package to organise the configuration, straight-package for reprodicibility and a set of swiss knife functions which may replace smex (either helm, swiper+ivy+counsel or the new suite orderless+embark+consult+...). I also suspect that more tools to help discoverabillty (such as which key) would be useful.Having emacs lock up due to being single-threadedOne of the biggest things was poor language support for languages I needed at work. In particular, it took a lot of effort to get a just OK environment set up for TypeScript with React/TSX and embedded GraphQL. I eventually went with TypeScript-TSX, the ts-ls LSP, and tree-sitter for syntax highlighting, but the result is clearly inferior to what I accomplished in Neovim with far less effort (and VSCode is in another class for this language ecosystem). I still could never figure out how to jump to definition between TS and JS files. Semantically incorrect closing tags are randomly inserted when writing code, and I could never figure out exactly what was inserting them or how to disable them. Support for Python was much better, but it also does things like autocomplete semantically incorrect parentheses after imports. I could never figure out how to stop this from happening, and I tried asking for help in a variety of places online without any luck. Things like pyimport-insert and lsp-rename still fail randomly while the equivalents work fine with other editors. Overall, my initial impressions after a year or two are that is Emacs feels very slow and buggy compared to other editors I have used. There are obviously some very powerful packages out there, but language support varies wildly and it takes a lot manual effort to get an environment that's reasonably consistent for use with multiple languages.lack of easy to understand documentation, old guides and forum advices no longer working at allDiscoverability, finding things, figuring out what can be done. 9 years ago package management was non-existent and configuration was very much more difficultGoing from terminal to gui made going from a vim focused workflow hard but I also knew terminal emacs wouldn't be enough.Key bindings in vanilla Emacs; complexity in using tagged regular expressions (when moving to GNU Emacs from Prime Emacs)It was hard to write the first config. As a result, it turned out that I needed quite a bit: a color theme, ergoemacs, modes for programming languages. Then org-mode and some things related to it were added to it. But it was hard to figure out the huge number of packagesYeah, that I didn't find Doom right off the beginning :P I feel like I spent too much time configuring plain Emacs when I had no idea what I'm doing, then spent too much time with Spacemacs which was harder for me than Doom. Also, I remember vividly how surprised I was to find out that company-mode had no documentation whatsoever, glad they added it (and it's impressive)!Nothing too bad, just learning the key bindings.Keybinds, ElispEditing megabytes json files freeze my emacsThe unusual keybindings (unused in many places except GNU Readline) and the concepts like windows vs frames were confusing.People always said that it has a steep learning curveI didn't know how to inspect the state of the application. Learning about how to get documentation for functions/variables/key mappings etc has been what made everything click for me.- Finding all the necessary packages needed for web development - Getting used to the key combinationsIt was fairly overwhelming, and following online guides gave me a needlessly complicated setup that I didn't understand.tui cursor blinkLack of familiarity with lispOut of the box , it just seems weird- it only makes sense once you customise itWas difficult learning vanilla emacs keybindings and forgetting muscle memory of vim. Learning the emacs way of doing things is different than the grammar of vim took some time. It is however closer to text editing in most editors that are non-modal.Paradigms can be very different, especially in terms of learning how buffers/windows/frames work. Mouse support is generally second-class, and discoverability can be hard.emacs lispMemorising shortcutsNo idea how to edit things in your config files, I was using spacemacs, so my config files were different than what was in all of the guides. Stuff that doesn't work out of the box would be an instant killer if you didn't have someone to guide you through it.Strange default keybindings (now setond nature) and a very dated looking interface (why not add a button to the main screen with a customization interface for newcomers)Changing habits. Heavily invested in tui vim+tmux workflows and had to become comfortable with an always on/always open editor.Varied advice regarding usage of certain packages with certain configurations, ie. different ways to load themes, customize-ui, etc...Lisp is a strange language.I started with Doom Emacs. every once in a while it would get into a state where it would not be able to update itself and I'd have to clone, install and synchronise from scratch, losing history, recents and everything that saves itself under .emacs.d. Starting to configure emacs from scratch was a slight shock, but not as bad as it could have been if I'd been new to emacs-lisp.Memorizing the KeybindingsDid not know anything about lisp, so configuring emacs was hard. Navigating between different buffers/frames was hard to learnForgetting the keyboard shortcuts. Confusion around buffer and window terminology. Getting stuck in a key command and not knowing how to exit.Changing keyboard to have meta-alt-control in this order, to make Emacs usableMostly overcoming its sometimes odd default configuration while not yet knowing elisp. An example would be Emacs littering the filesystem with backup files, lock files and autosaves. Moving those to their own directories within my Emacs directory required (for a newcomer) non-trivial adjustments of a bunch of variables. Emacs also dumps a bunch of stuff into your init.el by default, but luckily that was easier to change. (custom-file variable) I am aware that this is because of backwards compatibility, but for a newcomer it is quite the annoyance. Or atleast, I would assume so (it definitely was for me), as no other editor I know of litters the filesystem like Emacs does and this default behaviour is also changed in configuration frameworks like Doom Emacs.Weird bugsthe key bindings are very foreign; and the 'clipboard' behaves oddly.it is hard at first time but very very gratifying at the same timeLearning the keybindings/how to configure it to look and behave similar to what I was used toCommand discovery (what is possible), multi-cursor or block-editingVanilla key bindingsArcane and Obscure KeybindingAfter installing which-key, i learned quickly. (using Xah Fly Keys)Many. The error conditions while starting emacs, didnt directly point to where the problem is. Emacs started very, very slowly on my disk (no longer an issue). Ctrl and Meta characters were getting eaten by my window manager, so things didnt work well. My prompt was wrong and this broke tramp, (PS1) Symbol lookup in C didnt work. I tried using gdb in emacs on kernel panics, that didnt work (had to be modified gdb , ie crash).Key bindings, hard to remember commands (how to even search them/ find things in the docs), diff functionality still confuses me.default keybindings suckDiscoverability of keybindings, discovering relevant packagesI had to unwire my brain from vi keybindings. I was told to use viper-mode, but I the fact that emacs _supported_ viper-mode was why I switched (surely an editor that can emulate another was worth learning!), so I learned emacs from first principles.Many different approaches "Evil"/Standard Bindings/Spacemacs. Blogs and tutorials often implicitly assume one of these is used.The documentation was scattered in a bunch of places. This has improveded massivley in the past couple of years.The build of emacs 18.51 present in the HP-UX lab was just a bit too old.It's not necessarily specific but I think the greatest difficulty was just that it wasn't readily obvious how to use it in ways that make sense. I was just starting out in programming so I didn't have any expectations for my coding environment (which probably helped) so I just sort of used it like Notepad (albeit with color highlighting): it displayed my text and I wrote my text in it. There is a lot of intuitive decisions in how Emacs works which don't become intuitive until it's shown why; that may sound like a contradiction but keybindings are a great example. What keys go with particular commands (in this case, Control vs Meta) makes /intuitive/ sense – once you know what the commands do. And, being new and no obvious way to learn this, it was not obvious to me or apparent. Partially, it may have to be with how I approach software but I download and then use. It's, obviously, been a while since I've downloaded Emacs for the first time but, if I did, I don't know that I would have a different experience. A lot of the documentation in Emacs won't be obvious on how to get to, for a new user, and – even as no-longer a new user – I find the tutorial dense, if I even find it (as a new user). Approaching as someone with no understanding of the program I'm beginning to use, I can't quickly understand the benefits or the often fun(!) paradigm being built with Emacs's consistent design because the design isn't apparent, up-front.Language barrier .. lisp isn't a common language, and it takes a bit to get over the hurdle to be able to really tweak Emacs.Confusing interface, unusual key bindings, unclear error messagesElisp was tough to learn. I did not find the online documentation particularly helpful and did not yet know about the help and info systems.lack of use-package, dealing with major modes with wildly different key bindings.Package management was hard, until I discovered straight.elnavigating and manipulating buffers was a bit complicated. Getting used to keybinding.Navigating documentation in evil-mode, especially with no universal `:help` as I was used to from VimSo many keyboard shortcuts. Hard to understand all the options for packages and what they do.Learning the key combos - a cheat sheet helped alotThe largest difficulty is knowing how to put packages together to achieve workflows, as well as how to handle buffers, windows, frames, popup frames.Keybindings (before using Evil mode); weird defaultsAt first I found the GUI conventions and keyboard shortcuts to be unfamiliar.Default keybinding, maybe (I use it, but C-c, C-x, C-v is more "global").Key chords, learning the core set.Learning what is wrong(e.g. not using $emacsclient -c instead of $emacs. Configuring .../emacs.d/init.elTwo things. Vocabulary like 'kill' and 'yank' instead of 'cut' and 'paste'. The in-your-face GNU propaganda: The very first thing that I did to customize emacs was to remove the splash screen.shortcutsUnderstanding how keybindings worked was difficult initially, this might have been exacerbated by using doom with evil in the beginning. I remember local leader binds being a problem but it didn't take too long to wrap my head around it.Keybindings, mental model of how Emacs worksKey-Bindings are hard to remember when you are new. I used evil-mode for the first 5 years and only switched to the default bindings when I purchased a specialised keyboard last winter. Knowing a decent pool of bindings, it is much more natural to use emacs that way, but getting there was hard.It just takes time.Learning the keystrokes The fact that linum-mode is not enabled by defaultLearning all the keybindings felt overwhelming at first; and I didn't like vanilla Emacs, but I hadn't yet been introduced to DoomEmacs.I tried using emacs a couple of times and gave up while reading the tutorial. It all just seemed like overkill, starting with the keybindings. Later on, as my programming experience grew, I realized I needed a more powerful tool and decided to just commit to learning emacs.None, although this is due to using a well documented configuration (Doom Emacs)Configuration breaking my emacs install. Customising packages.I made the initial heavy investment to learn Emacs because I saw the potential it had (I've been using it as the sole programming text editor for the last ~11 years). However, it did take a long time and had I not been extremely interested in Emacs, I might have lost patience and gone for a more traditional code editor. That initial investment can be a make/break on whether someone wants to adopt Emacs.Alien key bindings, several packages that were causing slow-downs and crashes when used for remote buffers.Keybindings, what extensions to install snd howTerminology from Emacs' Documentation can be weird or counter-intuitive sometimes to a beginner.Reliance on elisp in configurationSure, knowing terms like C-a/M-a as Control-a and Option-a. The mac version had a rather nasty bug when saving using the mac gui (Command-Shift-s) and if you make a new folder it crashes. Another one is themes, and just trying to modify a theme, or switching between themes. Knowing what minibuffer/fringe/frame/window/echo area are. delete-selection-mode not being on by default.lispOut of the box I could not do anything with it. You have to read hundreds of documentation pages to achieve a working task. Documentation is fantastic but reserved to english speaking people with technical skills. Starting alone with emacs needs a lot of commitment.I failed twice adopting vanilla because of it's keybindings - spacemacs with vim bindings was my entry drug. Now, with homerow-mods, vanilla feels nice too.Some tricks make performance much smoother, but are impossible to find.Not understanding standardsSome of the words used to describe parts of the editor that I had never seen used before. Basically, how Emacs uses buffer, window, and frame. Also, words such as yank, kill, region, Meta, Super, and Hyper.I ran the tutorial and gradually read the manual and the Elisp manuals. Learning went very smoothly. There were three pain points: 1. Using Emacs as a programmer's editor. I found that as far as using Emacs as an IDE went, it was like I had been presented with a huge bin of lego bits and no Constructopaedia. Sure (in theory) you can piece things together to have a satisfactory programming experience, but after years of trying I never achieved it. I tend to program in other editors (so I'm not perpetually fighting with Emacs's indentation ideas), and run my tools from the command line in a terminal. 2. In-buffer completion. This is another thing I've never got working satisfactorily and have long since given up on. I just type things out in full or use abbrevs. 3. Minibuffer completion. I make do with fairly basic minibuffer completion. It's adequate but I know it could be a lot more useful. A few months spent here and there with various completion packages have resulted in more frustration than success -- the documentation of these packages is often poor (or non-existent) and there is a definite assumption on the part of the package authors that the user already knows how they work -- and more significantly, what they do.Sorry, to long ago.Of course, it was hell -- I only endured because I trusted Stallman/Spolsky/Yegge/Atwood/Graham's convictions that it would pay off, and also because there was no other (comparable) editor for Common Lisp (and now Clojure)buffer management, getting helpBig learning curve to understand elisp configuration files.Starter kits such as Doom Emacs hindered my Emacs learning experience. Doom Emacs abstracts away essential knowledge. External documentation was or still is incomplete. Old documentation is gone. Dead links floated around everywhere. I also didn't know how to access Emacs' self-documenting nature. Hence I was mostly stuck with opinionated defaults. Everything unsupported remained unsupported because the Doom Emacs community replied with “Learn Emacs” or “Maybe VS Code is better for you” to my cries for help. So I dropped Doom Emacs in favor of vanilla GNU Emacs.Getting started. It would be nice to have something like vim's vimtutor.Remembering all the key combinations. I used many cheat sheets, on paper.Just a general feeling of being overwhelmed, but decreasing after I started to get more familiarThe plethora of seemingly disjointed keystrokes...Initial out-of-box experience was painful; unfamiliar keybindings (struggled to replace learning of vim bindings with emacs ones). The learning curve towards getting productive seemed to high; as a result initially started with doom-emacs, since it gave a semi-familiar environment to work with. More recently have been switching away (with a couple different attempts) to a custom/semi custom config.Wondering: why we need ELPA, MELPA at all, why they are not built in already, why many of the default behaviors are insane, where did the warning message disappear, why is it so slow to initially run.- Vanilla emacs is much too far from a usable editor (for programming) - I did not invest in lisp (and still didn't), so I am bound to copy/paste and slightly edit what is existingThere aren't official docs on how everything fits together like packages and where they are store etc. so other than reading the code and (installing and reading the docs for things like use-package) there aren't many reliable ways to find out about them. Coming from a vi background I like the vi keys, because its so much easier to hit without moving the hands unlike Emacs combo keys, and also I felt how bad viper?/evil mode was (when I tried it some years back). All the weird Emacs quirks that are unique to Emacs like in regexes.Remapping my known keyboard shortcuts to the emacs versions; ctrl/meta key on linux vs ctrl/meta key on macOSelisp and weird key bindings.The initial tutorial & the fact that (e)lisp is required to be a power user.Due to lack of knowledge, I was not understanding error messages clearly, but internet search was enough to solve them.The default experience is not that great. It was only trough the use of spacemacs, then doom emacs, that I managed to get into and understand what emacs is. First after knowing what emacs is capable of trough the use of a distro was I able to scale back and finally write a smaller config of my own.Remembering Keybinds I don't use often. A bit of gymnastic required for some defaults.It's been a long time, but I know the terminology (frame vs window, window != window, buffer != window, kill, yank, etc) was a stumbling block. Learning the basics I think wasn't too hard (no harder than any other editor of the era) but it took years to slowly add useful new features to my day-to-daythe way how the hotkeys workIIRC Learning keychords and the historical jargon (e.g. kill, yank, mark). I remember having several false starts with Emacs until I was really driven to solve a problem: getting a decent REPL to experiment with CMUCL. This was a time just before SLIME. Emacs and Lisp have given me an appreciation and an interest in computing history. I now appreciate the jargon persisting but I can see how it's a barrier to people wanting a quick introduction.EverythingNothing significant. If I'm to mention something, I'd have to say it was a bit big and heavy to download, build and run on the far more limited networks and computers available in developing countries 30+ years ago.Unfamiliar terminology (frames/windows), the sheer size of it. Having to configure and integrate various packagesGetting a conceptual understanding of how you are supposed to use it.It was hard to understand things at first. It took quite a time to learn it well.Configuration quickly became messy. Had to rewrite it several times.The keybindings. It was a steep learning curve but there's no other way around it other than use the program..It's not vim and plug-ins to make it vim were not 100%The sheer number of options and knobs a new user can turn is daunting. It takes a few years until you start feeling at home in Emacs, especially if one starts to want a more modern look One of the greatest features of something like VS Code is that "it just works" has a sane set of defaults and those can be easily changed and it looks much more modern out of the box.Finding the setting you need to tweak to achieve something.I was not (am not?) a "computer person", and picked up Emacs in the mid 90s from a few fellow students that were. There was no mainstream internet back then, so I was wholly beholden on those who did know how to use it. tl;dr lack of learning resources that were a part of Emacs' general "self-introspection".slowness. without native comp, it's unbearable coming from vim. with native comp I don't notice it all the time, but it's still meh. Also cryptic errors. like some stringp nil stuffTerminologyMost things LSP solvedConfusion about setting variables (buffer local vs. not, setq syntax) in the config plus general LISP ignorance (quoting vs. not quoting). Trouble looking things up and getting answers I did not understand. Different kinds of word-wrapping. Getting emacsclient to lazily start the server and connect.It's definitely non-standard. Also, starter kits tend to break in weird, unpredictable ways.how to find keyboard keys/commands requires google and isn't necessarily built into emacsTrying to remember keyboard shortcuts, difficulty debugging issues, difficulty setting up lsp. Before using Doom I just didn't know where to start.The main issue I had when learning Emacs for the first time was coming to grips with LISP, but those were mainly conditioning my ears to listen for parenthesis first instead of C-like languages where the parenetheses come after the function name. With a slowing down of the speech, and a bit of practice, this is second-nature now.Learning keyboard shortcuts.Too many low-quality builtin packages. Weird dichotomy between stuff that is configured programmatically versus things that are configured through the menu system. Why is there a menu system anyway? With games? Why doesn’t the preeminent GNU application use GNU-style command line options? And why have a separate emacsclient executable? So confusing.Popping up errors because of the configurations.- complex non-standard UI (buffers/windows, modeline, minibuffer) - configuration interface is complicated. - elisp is not python.keyboard shortcuts, line wrapping, not knowing how to customize Emacs without a lot of effort, not knowing the benefits of using Emacs and it looked old (back in ca. 2006/2007)It's hard to get past the visuals of vanilla emacs when comparing it with contemporaries.Discoverability is horrendous out of the box. I could not figure out how to get help or even access a file. Internet helped a lot Many defaults are not suited for beginnersToo many possibilities, very few defaults.I only remember being annoyed at some elisp idiosyncrasies (forgot details by now), also while documentation is good, discoverability of features is subparTraining muscle memory took a minute.Yeah, Lisp is not an easy thing to learn as it's quite different from other programming languages and there wasn't any good documentation aroundSome Spacemacs layers like the TypeScript layer seem outdated and sometimes parse syntax incorrectlyKeybindings paradigm is very different from MS Office styleGetting used to moving the point using keys that aren't standard in pico or the Windows world took some time (e.g. C-n instead of down arrow and M-v instead of PgUp).Learning the keybindings, getting into some state or mode where the key bindings don’t do what you expectI remember following vim tutorial very easily i one afternoon. For emacs i become frustrated. I completed the tutorial over a week because everyday I stoped due to frustration. After that, and taking it easy I fell in love. Since I use Ubuntu I spend a lot of time untill I figured out how to install full complete manual.How to scan and read info/help properly. And come up with most suitable keyboard remap to press Ctrl and Alt both hands easily.Bad defaults and I wasn't sold on the value proposition to try hard to learn. Massively overwhelming, far too many built-in packages, only by being in the community for months can one osmotically learn stuff. (Doom fixed all these)Emacs-Lisp is maybe does not have a Lisp-beginner friendly tutorialThe lack of a templated framework (such as Doom/Spacemacs) was a barrier to entry. Only after learning the framework was I able to truly appreciate emacs for more than the framework.Too many tutorials out there. Don't know which to trust. Many of them have parts that are obsolete so it's confusing. The doc / manual isn't so easy to start with either. I think usually the newcomers have specific things to accomplish. Most of them cannot buy it if they first have to be drilled with "read the doc".The defaults (user options, keybindings, etc.) immediately demand changing, leaving me with no time to just learn Emacs as-is, but urging to alternate between learning and coding configuration from the startI initially had problems figuring out how to use the manual. But I was young and had time to spare. Definitely paid off :)Learning hasn't been difficult, there is good documentation. OTOH, setting up a decent experience is always a painful process. Barebones it has weird defaults and, specially in macOS, looks horrible.Huge learning curve, a lot of manipulation errorsthe manual is overwhelming, no good elisp introductionLSP support for any and all languages is still very unmature. Also emacs get stuck a lot when ever a task is being completed in emacs it is completely stuck ( It my biggest pain point to this day).juste to learn the key bindingsshortcuts and discoverability, before i knew M-x.1. Outdated/uncommon terminology makes it very hard to connect documentation/resources with my mental models. 2. Difficulty of programming in elisp for customization even when I'm proficient in other languages. (eg: are there recommended packages equivalent to a good standard library, what is good programming style, is there a recommended pattern to customizing packages and making tweaks, etc)Lisp being so different to other programming languages.elisp is hard to learnLearning that Emacs has a different way of handling keyboard shortcuts and commands, compared to normal text editors. Also different way of customization.Conflicting ways of achieving the same goal confused me. Setting the font I remember finding quite painful.It's very very obtuse compared to modern software. Finding out how to do a given thing in emacs, or even if a given thing is AVAILABLE in emacs, is not easy compared to modern editors.too many unneccessary packagesExpected some things to work out of the boxConfusing configuration with UI and code. Weird keyboard support, such as CTRL-C, CTRL-V not working out of the box.Buffer navigation, setting up melpa / marmaladeadding path to packagesKeybinding discovery. What did what and why did they work that way? I still don’t knowYes, too hardI have unsuccessfully introduced Emacs to several individuals. None have retained their use due to the steep initial learning curve.Too long ago to really remember, but I recall chords were a surprise I had to get used to thinking of.Some of Emacs' terms are a bit dated and should be changed: frame -> window point -> cursor Emacs ignores standard keybindings. C-x, C-v, C-c all mean different things on other applications.i use dvorak, and some of the keybindings are set up for mnemonics or ergonomics for qwerty users. that's not so bad, though.Previously there was difficulty in setting up some code completion plugins. Its a lesser issue now thanks to lsp support which mostly works effortlessly.Not user friendly for eu. Users (keybindings, keyboard, special ch., typographyI cannot get my head around elispUnfamiliar keybindingsOne should start learning Lisp to understand Emacs.Entry of commands that take multiple parameters is tricky in comparison with vim's : that just allows to edit parameters as plain textConfiguring is not straightforward task.It was 33 years ago ... I was putting ESC everywhere since I migrated from vi (not vim, vi!)the keyboard shortcuts are horrible and continue to be horribleVarious OOTB behaviorsLisp syntaxElisp is very different to anything I’ve written. Accessibility/discoverability of documentation was hard, though I know how well documented everything.Packages are useful, but how keybindings work is still something of a mystery to me, so when one package overwrote another's keybindings, I was at a loss on how to fix it, even after extensive googling.Too many new keybinds that differ significantly from the rest of the editors. Project.el is confusing at first, as it is unclear that a project backend (e.g. Git) is mandatoryLearning all the hotkey combinations.Un-grokking vim from what's left of my brain.lots of shortcuts, difficult to understand the work modelBiggest one would probably be that keybinds you'd expect to be somewhat universal, like copy & paste, don't work. Not as severe as the "how the **** do I quit VIM" experience but not great.Poor discoverability. Tends to expect you to memorise 200 keybindings, uses its own lingo. You can't just right click and easily discover functions as in vscode - mostly is hidden behind various text search menus that often return incomprehensible results. Could do with being more of a gui.Lisp is generally pain in the ass. Learning Lisp just to mod your editor is absurd and repels people off. We have to create bindings for other scripting languages asap in order to not push young people away.It was "weird", but since it was the first programming text editor I learned, anything would have been weird at that time (~2005), so it ended up being fineThat was too long ago.Low knowledge about commandsIt's been more than 30 years... Remembering key bindings. Remembering which functions do what.- The key bindings. I felt inclined to change ALL of them and kept it at that. I WANT c-x, c-c, c-v and CUA feels bad. - The customize system. My configuration is in an org file and I do not load the customize file because I have the feeling that it might unpreictably break my specifications. I only use it to get names and write them to my configs. - It was a hell of a ride to get the configuration flying, yet the above named starter packages all seemed too complex. Something in between might make it easier but I'm unsure if that's necessary.Keybindings...Not anymoreit was hard until I had the editing commands in muscle memoryThe thing is that you can't find the settings for elisp or Emacs itself as quickly as vimhelp. I especially had a hard time setting up init.el the first time.Initially I just used vanilla emacs, read the tutorial and everything went well. Then I started customizing and trying to understand all the different subsystems and how they interact was quite challenging. I've never found a good part of the documentation that gives a high level overview of how the whole system works together.Bindings and UI choices driven by implementation instead of user experience; you have to configure most things before they become useable; multiple packages do nearly the same things, or have overlapping responsibilities; overly complex packages or with bad code designJust remembering the keybinds, especially as someone who does not home-row.The learning curve is steep and makes you feel lost and helpless.These damn default keybindings. Lack of elips proficiency. Probably wouldn't be here if it were not for doom.A lot of keybindings to learn and a lot of configuration for it to be comfortable to use, initial user interface was overwhelming.Missing text editing options from vim whithout evil-mode.Too much ways to solve (nearly) the same problem (e.g. helm vs. ivy vs. selectrum vs. vertico, eglot vs. lsp etc.) On the other side, this is of course a strengthI'm not a programmer and have a pretty light knowledge in it. I'm a physics undergraduate and started using vim because of UltiSnips to write LaTeX but I discovered I could do something similar on emacs while having the advantages of a GUI program, specifically the LaTeX-preview command which blew my mind. I started learning elisp with the tutorial in the gnu site, but I find programming to be incredibly boring. My difficulties when using Emacs are similar to when I started. Not knowing programming, when an error occurs it's difficult for me to search on the internet to find a solution because english isn't my mother language and I didn't know any jargon. I'm more used to find help online, but it still takes some time. For example, I tried using emacs 29 but it gave an error with org-noter (a package) so I immediately downgraded the version. Getting used to the keybindings was a bit overwhelming, but now when I use a program without them it gets me crazy, and I still learn different keybindings everyday.All those damned chords and key bindingsKey stroke short cuts were not intuitiveLearning another new set of key binds Learning another new pattern of buffer and frame managementTerse and novice-unfriendly documentationSome of the basic editing and navigation commands are unintuitive relative to other common text editors that I was accustomed to.tutorial goes from zero to up very quickly!Modifier keybindings, non-CUA keybindings, Emacs LispI started with spacemacs because I needed a robust Clojure IDE and although it worked well it was harder to really learn what is fundamental to emacs itself.It took me a while to learn ElispKeybinds take awhile to get used to. For modern keyboards, remapping caps to ctrl is nearly mandatory to make this work as well.Breaking the pattern of thinking in terms of "buttons" instead of "functions"using the help, i still dont know how to use it, i google things. and doomemacs helped me get a configuration that i cannot do without learning moreCompletely different to all other editors. Outdated documentation for previous releases. Understanding how to get packages; stumbled on MELPA while looking for something else. Understanding that the documentation was worth looking at: I was used to doing internet searches for everything.The default keybindings took a while to get down. I kept telling myself I needed to figure out a better binding system that isn't too pervasive like Evil was but laziness got me stuck on C-n/f/b/p in muscle memory.I am still new and still struggle. The key bindings are rough. the official online documentation is almost always just information overload, it needs to have a "cookbook" or quick configuration part for built in packages. There is no wiki that is up to date and complete. I do not understand all the duplicate built-in packages. I wanted to use gnus for rss and email but after struggling i found out that it does not support atom feeds. why are these packages included if they do not use up to date standards? why does tramp use things like sshfs when that project is dead?2 out of 5 stars as a vim user using doomemacsThe keyboard shortcuts were a bit confusing since they are not in line with other applications. For example, C-x u instead of C-z, C-x C-c instead of C-q, C-x 0 instead of C-w, M-w instead of C-c, and C-w instead of C-x. But eventually I got used to them and have now configured all my other applications to use them as well.the emacs native keybindings are nowhere near as good as VimGetting started with writing emacs lisp was difficult. The documentation for writing things larger than a small function or two didn't exist or was difficult to find. I think this is still an issue but now with more and more packages being available there are more examples to look at.Finding the relevant documentation was hard at first, as I searched online the irst place, later learned about the in-built helpKeybindings aren't as discoverable as they could be (despite people often listing this as a strength), documentation is complex because the system is so large, customisation conflicts constantlyThe idea of start from a distributioin is not popular then. So I started by configuring emacs from the scratch. It needs too. much effort and the whole experience is frustrating. Beside, EVIL is still not mature then but I prefer Vim key bindings.debugging elisp and figuring out why something isn't working, debugging why package configuration isn't working, and overall figuring out why something I want to happen doesn't happenChords are unintuitive at first. They seem complex and almost arbitrary until you get used to them.The user interface (buffers, mini buffer etc.), keybindings, names of things like window/frame and cut/kill are very different from other software I was used to. This meant that I couldn’t use my intuition and past experience to figure out how to do something, but had to learn a whole new paradigm. This paradigm isn’t a bad one, and it would probably be difficult to change it without losing a lot of the power Emacs has, but it was a challenge in the beginning.I like to know what I'm using but the emacs manual and elisp are hard to get intostart slow and bad performanceWithout a starter kit, I was lost. Because there was so standard way of defining packages. There were straight.el load a file and package.el. This was too much.unfamiliar keybindings and hard to discover conventions (for example C -> M -> C-M progression as in C-f M-f C-M-f)I was learning Clojure at the same time, so it was hard to focus on any specific aspect of it. Getting a lot of new stuff working is hard.It is rather hard to learn all the nice stuff it provides, I am 25 years in and still learning new stuff. Lots of things are hard to debug, especially as various (minor) modes can interact strangely and packages solve partly similar things following completely different philosophies. It happens that I have no idea _which_ mode/package exactly is responsible for some specific behaviour (especially after testing several for some reason)I could not really use proficiently Emacs until I stared using Spacemacs, and then switched to Doom.lisp and the insane meta keybindingsWhen I was learning the keys, I often hit the wrong ones and started some function that wanted me to enter stuff (or even accidentally started recording a new macro, I was using evil keybinds back then, because that was the standard in Emacs Doom). In panic I wanted to quit that and hit ESC, but that sometimes didn't work, and I couldn't remember C-g. Also, it took me some time to get together all the settings for writing prose, at first Emacs seemed to be something for programmers only. (For that reason I put it away again a few years ago when it was shown to me by an enthusiast.) Now I have a great setup with Olivetti and a proportional font and visual-line-mode and can use Emacs as I always wanted.There are a lot of functions and variables in Emacs. Which initially made my experience a little hard. To get near perfect Emacs to my liking I had to search through a lot of docs.memorizing the Meta-x commands is burdensome. Also, keybindings on Mac are not very intuitive.Not installing helm soon enough.Nothing made sense because I was going off Stack Exchange questions, YouTube videos, and blog posts.Started using in a terminal with emacs -nw, tried to customize using the built in gui. Both turned out to be wrong approaches in my opinion.It was not a popular choice and had to Leanne it mostly on my own at the beginning. I still know very few fellow eMacs users.Installation and editing paradigm shiftKey bindings were awkward coming from vim. The menu system seemed badly organised to discover features.Frame, window buffer differencesThe keybindings. Before configs like Spacemacs and Doom it was too complicated to switch from Vi muscle memoryThere is a lot of new concepts to learn but no obvious place to find the idiomatic and up-to-date way to do things. It is far easier to findu references to third-party packages to accomplish something that is likely already provided out-of-the-box.Starting from a basic installation, I felt that the default M-x behavior was opaque. Once I had annotations up (via Counsel and now Marginalia) I could begin to see the commands and their purpose. Further, having live-updates narrow the commands as I typed really helped me "see and feel" what all was available. In other words, M-x was the brochure pamphlet that gave me hints of all that was possible.Customizing it according to my needs and use case was hard initially.I learned before you were born, so no :-).Copy and paste, but a little time getting used to the keystrokes became muscle memory.. Now I accidentally close a browser window.remembering the keys, writing elispShortcuts and sequences still make no sense; I am remapping everything extensively to my taste.Besides the unusual key bindings, I remember being confused on how to install it, as on Windows there's a couple of hoops to go through to end up with a .zip package rather than any sort of installer. I also remember installing msys to get Emacs, then being confused when it did not understand Windows paths. I remember having issues with CRLF, and needing to set various things in my initfile to get things to behave.The difference in terminology between emacs and other common editors especially around common things like windows & frames. Discoverability of features was also difficult unless I'm able to find a blog/emacswiki article that exactly does what I need.Getting used to emacs keybindings has been very difficult for me. Coming from VScode I was used to certain keybindings that are not in emacs. I also like that things are very intuitive in VScode which was not the case for me when starting emacs. (As I get used to emacs though, new things are starting to be more intuitive.) Also, I find that I accidentally hit keybindings constantly in emacs.The keybindings. They're just vastly different from any other text editor.What is C^ ? What is M?Slow startup given my often bloated configuration habits.Learning how to navigate Emacs. How to look at files, close it, navigate buffers etc. I remember being overwelmed and simply killing the window.The configuration model (that the init file gets executed on first launch, every time, from a clean state) was quite hard to understand at first (compared to other applications where the configuration state gets persisted).Ligatures not working out of the box.Not discoverable, too many key bindings- adapting to non-modern-standard concepts like the weird keybindings, kill ring, having a different name for everythingMuscle memory and conceptual framework from vim. Without these, the tutorial and manual would have been easier to follow and learn.Emacs keybindindigs are hardsteep learning curve.There were key bindings for everything (even though it teaches you the shortcuts on the go very well). Getting some personal configuration to work.in my case I haven't documentation in my mother languageAs far as I can remember, the built-in tutorial was great for onboarding. After that, I just kept poking and messing with Elisp. I never felt Emacs to be hostile, on the contrary: it always seemed like a welcoming playground.The many ways of configuring what seemed to be simple, e.g. keybindings, themes, fonts.bindinsI would not have learned emacs if it was not for projects like Spacemacs or Doom. Seeing what a complete config could do really made me want to learn it.Getting started is relatively easy; learning movement in files for example. But moving beyond, and making Emacs actually more efficient, was the biggest hurdle.Learning keybindings and ELispLearning how to operate the user interface. So many keybindings and you have to learn them all before you can be productive. Also takes time to learn emacs concepts like buffers and how to manipulate them via programmingOverwhelmed by the number of optionsIt's difficult to recall even just one year later. I definitely had some hurdles. I started with doom emacs right away, but stuff like how to install packages and configure them wasn't easy to understand. This is probably more a problem of dooms documentation. I think it wasn't immediately clear to me how to best google to get answers. The whole mailing list system is still extremely cryptic to me and to all young people i talk to (and I'm studying computer science)Really hard to choose a distribution for MacOS. Some has glitches on re-draw. Others can't use MacOS key-bindings like Command + ` to alternate between windows.Making a performant configuration (started out with slow package loading), keyboard bindings didn't 'feel' comfortable (Solved with viper and recently, evil)Learning the new workflowTIMTOWDI and all the fragmented tutorials and third party documentation.versatility, getting it to run on windows, getting it to run on multiple computers, figuring out gitArriving at sane defaults. There are so many options it took forever to adjust behavior for each language I worked with. This led me to try config frameworks: Prelude, spacemacs and eventually doom. Although they’re powerful it’s a shame that defaults aren’t geared more for the most common use cases.Initial configuration to get a setup I was comfortable with. Vanilla keybindings where a struggle. Especially when using CUA Notepad++ or Vim as fast batch/shell script editor. DoomEmacs Evil mode gave me cross editor compatibility between Emacs and VimHad to read the built in tutorial. I've learned a lot from other people's dotfiles. Also GTD guides.Too much documentationI declared emacs config bankruptcy at least 3 times during the course of trying it. I first tried to use emacs on its own i.e. vanilla and ended up not using it as a daily driver but stopped. Spacemacs got me curious enough to play around with the configurations but the style of configuration and overlays didn't work for me. Doom Emacs was the sweet spot for me; it provided enough tooling and was geared towards using vim.The tutorial and the documentation very clearly spelled out how I should expect commands and chords to feel unfamiliar until I used them often enough to push them into muscle memory, but because that's not how I learned vi/vim, I didn't believe it. It took me a couple of years to get over that initial hurdle. Also I wish there had been a bit more emphasis in the documentation aimed at newcomers in their first ten hours on M-x describe-mode and C-h k / M-x describe-key. Eventually learning that these tools are available everywhere in emacs was what really made me feel like I couldn't get lost anymore.Not well.The command keys (C-x etc) were initially difficult to use. Remapping control to Caps lock helped, so did reading some print manuals on Emacs.package discovery was hard. I only really got into emacs once I found someones extensive literate config on GitHub after trying vanilla emacs and spaceman's multiple times and bouncing off. default keybindings, especially in specific modes like eww were a pain to learn and while I like how easy it is to look them up, I still haven't quite gotten the hang of modifying them (especially with evil-mode added to the mix)This is a long time ago, in the early 2000s. I was using NEdit which is an X/Unix editor that uses CUA. It took me a while before in internalized how Emacs differs from CUA editors. I never got along with the CUA mode in Emacs although I suspect it has improved over the last few decades.Everything broke. It's extremely slow, so not knowing C-g is painful. Emacs doing everything on a single thread is a complete joke.Understand the doc.elisp, initial config changesI am still quite a new user to the world of Emacs. I have been using Doom Emacs since I am already quite used to the Vim keybindings. I found the navigation within Doom Emacs to be quite straightforward and the hotkey navigator to be super useful. I have also found the init.el package list in Doom Emacs to be very helpful and it got me 80% of the way there to my ideal setup in less than 15 minutes. I would probably say the biggest difficulty for me learning Emacs would have to be learning Lisp/ELisp. The syntax for Lisp/ELisp has been quite hard for me to get used to and it makes things relatively difficult to customize things to my exact liking. I probably should try and take some time to really get to learn the language. Compared to Vim/NeoVim I have also found internet searches to be a bit more sparce when I look up questions I have. Sometimes I don't find much when it comes to troubleshooting or trying to get pointers on how to write some ELisp to achieve some goal or trying to research a specific feature I found with Emacs. Coming from Vim/NeoVim some more documentation on how to write custom keybindings in ELisp would be fantastic.What works on Linux vs what works on windowsI was struggling with understanding Doom for a long time and kinda just doing what worked, a TUTORIAL would've been helpful (looking at you yeet and teco) Yes, I know I probably predate you both.Key-bindings and commands are hart to learn. This only became better after installing which-key, ivy and counsel. Missing translations, even for the core.package management was/is badNot easy to use it the first time. Didn’t understand how to configure it. Not usual shortcut to copy/past or save.Lisp is not myUnderstanding elisp -- which I haven't done thoroughly -- and the way Emacs loads and uses packages. Lisps in general are a little awkward for the casual programmer, and it's difficult to parse nested parentheses, quotes, back quotes, odd-names like `car' and `cdr'. Yes, there is a lot of documentation and a few guides, but it takes a bit of practice to really learn and understand, which I'm still not sure I do. But I am not sure this can every really change without fundamentally altering the core of Emacs, which I wouldn't want to do. Package management -- installing, updating and removing packages -- was not clear to me to begin with. The `use-package' macro was helpful. It's also not obvious to a beginner how one should update a single package or a subset of all upgradable packages.Extensive coding needed to fix the atrociously bad default configuration and keybindings. Especially the keybindings, even for plain old text editing. Utter failure of fully changing the default for cancel/escape/quit/etc from C-g to something else. I have lots of bespoke config to cover the common cases, but edge cases still keep popping up after ten years. Emacs documentation and propaganda should stop claiming that the keybindings are reconfigurable by a mere mortal, when that's not actually true. Or move ALL keybindings, with NO exceptions, to a package that you can call default-keybindings or whatever. Then when installing Emacs, ask the user, "do you want to use the ancient insane keybindings, or one of the following vastly superior community-maintained alternatives?" (and provide some options).I started using vanilla emacs, and I felt a bit overwhelmed at the beginning looking for all the packages I needed to make it look like a lightweight IDE. When I started using Doom Emacs, I realized it does almost everything I wanted from Emacs that I had in my configuration, with giving me a lot of freedom to customize it.Key Bindings and Emacs Lisp.Keybind customization. Changing C-h to delete-backword-char was easy. But I needed some days to remap esc-map to C-L correctly.selecting package, key bindingsYes. The barrier for entry seems kinda high. I started with Spacemacs which I enjoyed but left me entirely unprepared to deal with any part of what had been set up by it. I decided to go for vanilla for a little bit but I landed on prelude because it has done basic things I quite like. Throughout the process, I’ve definitely felt the need to learn elisp so I can deal with configuration files myself but justifying the effort is hard when I’m not sure if I’m going to stick with emacs.Buffer and window manipulation were poor. Still are but I got used to it.Memorizing keybindingsI felt there was a gap after finishing the tutorial. I knew there was plenty to learn after it, but it wasn't clear what and how. What made a big difference was reading the intro to elisp manual, which a friend suggested me to read. But I can also see how it is too long for most beginners to go through. I think beginners would greatly benefit from a "tutorial part 2", with similar length of the existing tutorial or slightly longer, introducing a few more things to new users before they have to go to "the wilderness" and learn things by themselves.During the first time I didn't knew elisp and stubbornly copy-pasting pieces of someone-else configuration caused my Emacs to crash very often and I didn't find the debugger very intuitive... that until I learned of use the help and various describe-something functions.Key bindings, configurationThe default keybindings were a bit of a hassle to learn, as I did not find any use of them outside Emacs. I should note that Emacs' keybindings do exist elsewhere, at least partially, for example in terminal emulators. ELisp was another trouble that I had, and honestly still do considering that I've yet to properly learn any Lisp programming language. There were a couple other things that I only realized later on were annoying for a beginner to face. Those things were either enabled/configured by default which I think was an unwise decision or simply unavailable. The two important ones are a selection framework and a package like Embark or which-key.What packages are available and what they provide. How do various packages interact.getting used to reading docsYes - but that was emacs 18.59: key bindings: unexpected behavior when unintendendly pressed a keyAt the time, the keyboard shortcuts for copy/paste displayed in the menu were confusing (at the time, AFAIR they were displayed as etc. rather than M-w etc.).dont know which completion framework to use, and the original completion buffer is hard to use(selecting candidate is hard) emacs27 on Windows is too slowCommands and the philosophy- pdf-tools: it was not easy to set with Windows.keep forgetting keyboard commandsLisp as language used in config file.I would (and still do) spend far more time configuring emacs than actually using itDocumentation is very hard to explore, most info/solutions are from Q&A forumsUnderstanding the Emacs API, finding up to date docs, knowing what packages to use15+ years of vim use (evil-mode helped), decision fatigue in configuration.Learning and reading Emacs Lisp. But it was fun.It is very easy to feel lost, and drowning in complexity. For me, and I expect many others Elisp is a new language to learn and Emacs has some different ways of doing/naming things.The key bindings Finding the right documentation It felt esoteric in nature in the beginningSimilar to Python, Emacs has a lot of "batteries included", some older or less supported than others. It can be difficult to tell what packages/functions I "should" be using without being immersing myself in community sources.It took some time before the terminology in the documentation started to make sense. It can be a bit daunting at first to go through all the different package options to find the ones that fit your needs and keep reasonable performance. It also took some getting used to debugging the config for performance issuesNot enough reference implementations built around prose workflows. Too many package manager options, doubly so for completion frameworks. Crashes and hangs are still annoying and hard to diagnose given that I didn’t compile this distribution (from railwaycat’s mac tap).Keybindings not obviousMostly key-bindings and getting enough ELisp knowledge to customize Emacstoo many irrelevant error messagesThe strange keybindingsThe keybindings were different to what I was used to but now I prefer the emacs keybindings.Learning elisp was quite hard.Too difficult, like trying to get a sip of water from a firehose. Mixed signals from various tutorials, and getting a minimum viable startup took too long.Learning the basics was actually easier than getting from beginner to intermediate. Getting to intermediate requires a good working model of many of emacs internals. While there is good documentation at the function level, getting an understanding of how components of emacs interact, and how to write elisp that plays nice was/is difficult for a new intermediate user.Configuration ConsistencyMemorizing keybindings, windows managementThe difficulties I had 24 years ago are almost certainly not relevant anymore.remembering Keyboard commandsKeybindings are hard to memorize but it's a question of time.The keybinding system is difficult to understand.discoverability - that's been fixed now to a large extentLots and lots and lots of keybindings.configuring emacs (especially colour/faces)It's been a long time for me so can't recall but have noticed the following in others who have tried it. Vanilla Emacs doesn't help a new user to see the potential. To them it just seems like an outdated editor. Spacemacs or Doom are great but I've been told that they can be overwhelming. I think because Emacs can do so much, there is a lot to take in when first using it.Breadth of ecosystemYes. This is a well-known problem for people since the 90s. If you have to ask, you have a bigger problem.Configuration can be difficult for a beginner. It is also a bit difficult to initially understand how introspective and interactive the environment really is.There's too many ways to do things.There are so many options and so many ways to do things it is easy to get lost in the beginning until you decide what packages to use.Mapping VIM muscle memory to Emacs has been hard and eventually I gave up and adopted Evil mode. Starting with Spacemacs put me right into the game but then it has been a bit hard to get to configuring Emacs manually (but worth it)Looks weird and unappealing by defaultIt was hard to learn the shortcuts at the beginning. Hopefully, documentation was great and refcard helped a lot. Elisp was a bit hard to learn at the beginning too.It is slow, the syntax highlighting easily breaks, it is not clear how the different ways to configure variables interact with each other, and because everything can modify everything, nobody can be really sure about the state of the system any more. It is also super slow and mostly single thread, which is a shame. It is also hard to replicate a configuration on another machine.- google results often return obsolete or suboptimal answerd - as a beginner hard to distinguish different tribes of emacs - elisp conventions (like naming personal functions with 'my/...' are not immediately transparent - while the docs are really great it's hard to read this much as a beginnerSome keybindings don't interact well with OSX and Karabiner. A lot of keybindings are hard to remember and it's not super easy to add them to the menu. All the configuration options and packages are overwhelming and hard to configure but also necessary if you want a semi-decent programming environment. Editing the config requires some understanding of elisp which is a big ask for a starter.When I started it was difficult to remember the shortcuts, I used M-x a lotSometimes a keybinding is accidentally hit, and it is difficult to know it has happened. Finding the keybinding that does the dame thing as one of the GUI's menu option can be difficult.Install process would have failed without 1:1 mentorship. Long lines and other freezes/hangs were brutal. Vanilla/out-of-the-box emacs is actively hostile.Keybindings and buffer conceptsAll those crazy keybindings!I should have just done the tutorial sooner.I was worry by the immensity of the possibilitiesunfamiliar keyboard shortcuts, poor feature discoverability, lack of tabs/graphical way of organizing buffers, setting up file associations correctly to open in existing instanceI attempted to use Evil mode, but there were a lot of conflicting bindings which soured me on vim-style movement and made me learn the default bindings. This caused a lot of trouble, specifically when editing lisp code, I could never get Evil to work well with paredit. The second one was using a pre-packaged Emacs config, which I used to ignore what was customised, so when trying to create my own emacs config, it was difficult to transition to my own. This isn't specifically about the config itself, but more that the defaults of Emacs were very different to what I expected. After stripping away the config I was a bit lost because I didn't understand things like `customize', and the Emacs defaults.elisp is drastically different than vimscript and I had a hard time figuring out the new paradigms. I also had trouble figuring out the extension ecosystem, as I had some very specific things I wanted to port over from vim immediately.any part of the system that didnt have vim bindingslooks out of the box uglyLack of easy configuration options, unintuitive keybindingsTo discover discoverabilityI haven't got around Lisp yet.Difficulty using C - - on macOs, zooms out my view. Not clearly understanding what macros areIt was a struggle reading the emacs lisp reference manual. Need simpler documentation of writing custom configurationsThe fear of having a blank sheet of paper in front of you and not knowing where to start intimidates so much power.Emacs Lisp was the major difficulty, as it was my first serious programming language. Learning a new set of bindings took some time, but it was relatively smooth.Installing packages (it was before package.el)It has high barrier of entry, with all shortcuts being different. It requires a lot of initial config, but that can be solved with spacemacsFiguring out how to customize it and getting used to the key bindingsTerrible defaultsLearning keybindings (obviously :p). I also had some difficulties understanding how to start customizing (installing melpa and package dependencies)Can't remember that far back.Sure, it was difficult, although it was clear up front that Emacs mastery is a long and difficult road.The copy-paste keys, switching windows.The paradigm, that everything is a command.Learning the shortcutsThe first time or two I tried to use Emacs, I tried to get help about keybindings, and ended up seeing "Hello" in lots of different languages.hotkeysThe amount of keyboard shortcuts and the ancient alien, to me, ways of doing things were overwhelming at first. After muscle memorizing some of the shortcuts and configuring some stock packages like IDO, i became hooked. It also started to feel consistend in its own wierd way.Keybindings - evil mode helped, as did simply time spent getting used to things evil didn't cover.Getting a comfortable start we very difficult until I went into Spacemacs, and then into Doom. It was hard to know where to begin. I wanted something that would just work like my other editors, but Emacs took some hammering to get it so that I felt comfortable to just pick it up and being tweaking my basic flow.Doesn't work like other Windows editors (keys and terminology)Key bindings and discoverability. It was a plain emacs and I used it for org-mode only, retaining vim for everything else. Discoverability remained a problem for some time.Finding the right options for my needs and digesting documentation of some plugs-ins as a new user.I use vimNot major ones, besides having to read a lot. Which is fineWhile emacs' built-in documentation is extensive, the discoverability in base emacs is somewhere that I still see room for improvement. which-key (https://github.com/justbur/emacs-which-key) is a great example of improved discoverabilityI started with XEmacs and then moved to Emacs, so learning the differences between two similar setups was tricky. Frames vs buffers vs windows is always weird.Help findingNo. That was a long time ago!The in built help and manual’s navigation is not intuitive. The fundamental concept of Emacs takes years to get a glimpse despite extensive manuals and in built help.Some packages requir d extensive configuration, or dozens of keybindings that needed to be chosen before they became really usable, good defaults would have helped here I recall hard-to-google errorsKey bindings and how to look up help within Emacs.need to write elisp to configure.reading infoLearning the key-bindings, getting used to copy/paste being different than the native OS, near-vertical learning curve.Chords Vanilla emacs was not the best in terms of experience.Archaic documentation, many guides are completely outdated and configurations predate my pubescence lolKnowing whether to use default Vs popular package. How to evaluate which package to useI don't know why everyone talks up the built-in tutorial; it threw a lot of information at me up front, much of which I'd forgotten within 48 hours anyway. Many of my early weeks were spent learning the bare minimum to use it for ordinary editing (copying, pasting, undoing, opening and closing files, calling the shell, and other unglamorous things) before slowly layering on the "cooler" features (moving by lexical units, compilation mode) day by day, week by week. It would've been better for me to have been taught how to use Help commands, Info manuals, and other documentation tools right away; once I learned these, I was better able to educate myself, learning what I needed as I needed it, and avoiding information overload. And in spite of all the documentation, the most important things I learned about Emacs I would learn from other people; there many valuable features and options you'd never know about because they aren't mentioned anywhere in the program a newcomer would think to look. I also would've benefited from using the Customize interface more often while I was getting my bearings, so that I could start making useful changes immediately before graduating to Emacs Lisp.Not really... at the start I just used it as a text editor where I opened, edited, and saved files. I slowly learned about other packages over time.At first you have to continuosly learn and forget emacs usage at same time. Then you just forget about it and just let your motion take you.Incomplete or poorly executed integration among built-in libraries. Lack of standard key bindings and an inconsistent UX across built-in modes.lisp was hard for meHaha. You must be joking. The key bindings, the key combinations, all of that is awful user experience, awful awful awful. Decades into it and I still never know when or whether I can or should modify a key binding to something logicalRSIthe long and verbose gnu documentationOverly complicated configuration, default keybindingsLSP with lsp-mode didn't work. Have to manually install servers for major things Support for Js-python-HTML is not straightforwardYou have to dive in head first and not obsess about understanding everything at once. In particular there are often multiple packages built into emacs that have similar functionality that makes things confusing.Figuring out the daemon/client, so that I wouldn't have to worry about multiple instances. Like, if in a M-x ansi-term, something calls `$EDITOR`, I don't want it to launch a new Emacs. Not having to guess which instance a given frame belongs to.I was unable to figure out how to get my editor configured in a way that makes it work similar to modern editors I started with. I could throw some code in my init file but because there are so many packages pertaining to completion and other important features it becomes overwhelming. I'd prefer a more barebones configuration but due to this initial complexity I've relied upon configuration frameworks.I remember it being wonky compared to DOS editors in the 80s but easier than vi ion unixRemembering keystrokes and functions is hard, though which-key-mode makes it much better.escape from mini-buffer subwindow management不知如何开始I went into emacs expecting that I would have to do lots of customization before I would like it, but I didn't know which packages I would need etc. and couldnt really get started. A year with doom emacs really helped with that, and atm i'm quite happy with my custom config files. I also had to come to terms with that emacs was made with a certain workflow in mind, and sometimes adapting that to how you work is better than trying to redo everything your way.1. Elisp wasn't easy to learn as there are a ton of ways to do things 2. A lot of tinkering was needed in order to make emacs useful.Learning the navigation key bindings and learning elispBuilding on how Emacs treats me as a person, it also treats me as an expert in Elisp. This is a fine line and a difficult thing to manage no doubt, though is an obvious difficulty that I and I'm sure many more encounter. I am starting to acknowledge the power and benefits of using a text editor that I can configure in the same language that it is primarily written in, but the reality is that Lisps are not as common as the C like programming paradigms often seen out in the wild. This is not to say I think Emacs should be written in another language or changed or anything, only that there perhaps should be more emphasis on tutorials and educational tools for building proficiency with Elisp, or Lisps in general. This is largely handled by the community, and the Emacs community is fantastic, though I wonder if there are ways we could improve the pedagogy of learning Emacs for newer generations of users, who like myself had never heard of a Lisp before diving into Emacs.The number of packages, default bindingThe initial 'blank' config was not good. The 'customize' interface was confusing as someone who came from native GUIs.The learning curve for how to use all the emacs specific features - buffers, kill ring, custom defined commands, splitting the windowThe defaults are pretty awful and it's easy to scare people away.Learning about how Elisp, faces, and buffers worked and how to manipulate them.I didn’t know how to use introspection and documentation features very well (e.g. C-h f, C-h k, and the info manuals).Understanding and getting familiar with its basic key-binding. At the beginning, it's very strange from CUA(as a Windows) users.Key bindings took a whileRemembering important keybindingsToo many configuration options; many outdatedKeybindings are a bit confusing.The really weird defaults. Indentation's the worst, I still haven't managed to figure out how to make it behave in a sensible way, and not for a lack of trying. Most other editors just get this right.I remember the first time I wanted to customize an alist... Groking cons, lists, alist, and generalised variables took some time.setting up melpa, upgrading existing packagesasdfHow to configure the editor with extensions and write my own functions.Learning emacs-lisp and the internal functioning of the editor. I still find it difficult to inspect what specific mouse actions do or what functions are triggered by menu options (like when using embark). I was also missing examples of how to program simple actions in elisp, but eventually learned most of this by reading source code.The default environment is very alien: C-g instead of Esc, bright white background, calling Alt Meta. . Several times I ended up trying a starter kit like Doom just to know my way around, but that in turn has you learn to configure the starter kit rather than actually writing elisp. Thus introducing limitations. Eventually I stumbled across the built-in elisp manual, which is what led me to give emacs another chance. I ended up watching tutorials on YouTube to learn about packages and setting up a usable configuration.Only beginner tutorials availableConfiguring Java.Bad defaults.there is no documents in my native language (need to learn english to use emacs)I wasn’t hooked until I found the features that were “killer features” for me. The documentation also has a steep learning curve.memorizing key combinations and function namesDifferent nomenclature than contemporary software (kill,yank vs copy,paste) and different keybindings.The biggest difficulty for me was learning the Emacs keybindings. I have been a long time non-emacs user in my 20 year IT career, and was much more comfortable with modal keybindings. In addition, knowing where to get documentation or help was a challenge when first learning Emacs.It's so different from evrything I was used to.Remembering how to do things. Cryptic error messages.At the beginning it was kind of daunting. Lisp is quite foreign to many people.Terminal issues were a pain. Mismatched settings and stuff. Old emacses that didnt line up with new tutorials.The standard keybindings are rather unusual for someone coming from more "sane"-keybinding text editors (Ctrl + C, Ctrl + V etc) and also elisp can be a bit intimidating at first.No Japanese-language manual included.The UX was very opaque to me…until I tried Spacemacs which made features very discoverable. Though I now use Doom Emacs exclusively.Documentation (mostly outdated, targeted to specialists)The manual has no visuals. It was extremely difficult to figure out _what part of the UI_ it was talking about. I have to extensively use context clues sometimes to infer what it is talking about. The emacs manual is not a user guide. You need to know exactly what you're looking for. Pick a simple editing task like how to copy and paste and try to go find out how to do it using the hyperlinks in the manual. I'll wait. There are multiple packages available for completions. I have no idea what the default is. Learning how to use the interactive help was extremely difficult as well. No program I've ever used does help in this way. Navigation was also a struggle which made navigating the in-editor help difficult. I had my own config for a while when I was only learning to write common lisp. The slime package just mostly worked (it's an amazing package) and I really just had to configure one or two things. I totally gave up on managing my own config when I branched out to using emacs for things like static site engines for blogs where I'd mix HTML and a template language in the same buffer, and other languages that required stuff like language server protocol stuff for me to actually be able to work. The config became a rube goldberg machine that I wasted so much time on. It was very frustrating just trying to get emacs together so I could work. I gave up and started using doom. It still is difficult to config at times, but I can just enable a language and doom loads what it thinks are the sane defaults for that language from whatever packages. This of course has the downside now where I have no idea what packages I'm using. But why should I care anyway? I want to write code not configuration for my editor. There is so much up front configuration you need to do before you can - for example - start writing javascript with an even vaguely similar experience to something like vscode. It's frankly sort of agonizing. I want to use it for everything but good grief.Some default Keybindings can hurt 🤕Mismatch between evil-mode and built-in modes, this however has been fixed lately by evil-collection.It was difficult to remember keybindings at first.Unusual keybindingsLearning Elisp?No, it was easier then learning vim. I went through the tutorial and was ready to goLearning how to learn things, and how to close the help window, and just ... basic keybinds were hard! And configuration virtually requiring elisp is still to this day the most horrid experience possible, especially for a newb. Yes, emacs is supremely discoverable! IF IF IF the person performing the discovery __already__ knows how to get around in the interface AND, worse, the documentation is clearly written for people who are familiar with programming concepts.Putting a space after the headline stars * for org-mode...Learning elisp, configurating it to be a pleasant experience for myself. Accepting that I can't live with Emacs default bindings and learning vim/evil mode.Learning emacs internals was a bit of a struggle. There are so many configuration options and many ways of doing the same thing, it was a bit overwhelming at first.I started with spacemacs and it was *very* difficult to mentally translate generic emacs resources to spacemacsBackquote syntax is horrible. Understanding cons cell dot notation. Macro expansion.Learning lisp. Emacs settings.Keybindings, but the menu made that a lot easier.Memorizing keybindings; figuring out how to abort a command without resorting to killing the process.Obsolete elisp snippets found online, difficulty to setup IDE for projects (c++ in particular)Keybindings, chording. Early days, just getting it compiled on a given host. Package management used to be an issue.There’s an enormous amount to learn and it wasn’t clear where to start (besides the initial tutorial).not having CUA, even the whole two-stroke keybinding thing was weirdConfiguration; many people have a different style of including packages, etc. that seems inconsistent between guides. I wish I had started with and learned use-package before anything else.Dealing with a slow starter kit (spacemacs) and the overwhelming about of commands and configuration options. It was hard to get the productive language specific features I experienced in vs code and vimHad trouble with learning the shortcuts and keybinds without knowing the help function. For example, jumping to a certain line.Emacs PinkyNomenclaturetoo many packages in the coreKeyboard bindings took a while to get used to. It wasn't super clear how to install packages.Understanding elisp.Installing packages could be as easy as in VS Code. Now it is tedious, because trying a package requires at least a 5 minute investment. In VS Code, it is seconds.How to configure Emacs for programming. The stock UI is horrible!While I love lisp now, I have not always; jed (the editor I previously used) used a C-like extension language, which was more natural for me. Getting comfortable with elisp took some time. The default config is also kind of terrible, building up enough config to make things not surprising took some time.It took a while to learn enough keystrokes to become efficient. No regrets though.I was not very good with a keyboard and found the manual on the start page to be hard to read- mainly because I didn't knew how to zoom in. In therefore looked for docs in my browser and sadly chose unofficial (incomplete) tutorials and such - leading to great confusion.Not so much, but i had a really good mentor who wanted to "show me the way"I sometimes had trouble finding the documentation I wanted. I know I can use C-h a and such but I wouldn't use specific search terms and would get too many results, and it would be overwhelming.I struggled to remember the keybindings. The customization interface wasn't very intuitive to use.There's just SO much to do, and I tried to learn it all.ELISP, unsure which packages to use for my needs (where I needed more IDE-like features, code completion, hinting, ...)keybindings; memorizing keybindings; emacs is so almighty that it overwhelms you as a rookieVery confusing key sequences. Felt alien and not welcoming. What's a buffet?Elisp is not a beginner-friendly language. Emacs is not the most stable or fastest editor, things break or hang sometimesNot having a native modular editing capabilities interferes with almost all plugins.Discoverability is weakTo many to list, its a swiss army knife the size of switzerland. Its man pages probably reach the moon if arranged in a certain wayUsing it as an IDE/ setting up an IDE environment. Understanding how to install packages/ how to configure them to my needs. Figuring out which features are most relevant in the standard distribution compared to other community packages.Key bindings where a struggle, but the main issue was the lack of good default support for programming languages at the time. Finally an issue that remains is a good guide on how to configure Emacs, How to structure a config and make sure it uses the latest features and functions for optimal speed. So i always ended up with a mix of snippets from the web that used a mix of styles and functions making performance and maintainability bad.memorizing keybindings, keeping track of buffersToo long ago -- learned emacs as a gues on MIT-MC when it was still a bunch of TECO macros..I was willing to poor a lot of hours into it back in early 2000, not sure why… it was equally hard back then.keybindings were (and still are) counter-intuitive.I can't sometimes type thingsLearn keybindings, kill/yank instead of copy/pasteThe keybindings are extremely counter-intuitive to grasp at first. I'm not sure what you would change them to though.Well, it's too long ago.Documentation is scattered. Features are usually hidden, and really need to be discovered.Keybindings and windowing metaphor were very unfamiliarI'm not a programmer--I'm a medical researcher. I was drawn to Emacs by the promise of a very malleable environment that I can control. The biggest challenges were understanding how to install and use emacs and certain packages, then learning basic elisp, and now it's about maintaining performance as my library of notes has gotten long.Forgetting key bindings and text movements that are slightly differ from vim behaviour, e.g. zap-to-char word, M-f, M-bGet used to keybindingsStarter kits made it hard to figure out what did what!keybindings are hard to rememberLearning about packages and which packages are included in Emacs, learning about all package optionsYes, it required a lot of perseverance to get basic editing operations down. I was a user of the menu for a while as I learnt the common shortcuts. The depth of the customisation was overwhelming, and elisp was a significant barrier (still is all these years later).I've been using emacs since Gosling emacs and the first version (I think) that Stallman released. But something is always new to me and I have to go back and (re)learn things. I think understanding the world view and vocabulary, and then finding sources of expertise that match one's style. I think finding the small and usable emacs and growing from that was challenging.Setting up themes and fonts. And not particularly core Emacs related. Org mode was highly praised, but it was so difficult to setup and get started. Same with mpc, its a horror to use.It took me a while to find all the packages I wanted to assemble into my own Emacs system, but I think that is only natural.I learned emacs on the job through my mentor. He walked me thru his config and I used that baseline for a decade. Keybondings were odd at first, but he first stepped me thru emacs introspection features to allow me to perform intermediate debugThe vanilla startup interface is not attractive and requires extensive reconfiguration to make workable (or recognisable or modern). Configuration is difficult as long as Emacs lisp is unknown to the user. Emacs became a joy to use only after I learned Emacs lisp, but I was not a programmer, so it was a very difficult hurdle. Getting into Vim is easier, but at one point all Vim is entirely explored and one can move on - to Emacs.The key bindings.Mainly using elisp.Remembering all of the different key bindings.Keybindings mostly, its relative roughness when coming from an IDE like Eclipse where everything is easily accessible with a certain amount of clicks. The need to customize it to support some languages when you're not used to the configuration.KeymapHard to find mid-level proficiency tips. Like, it's easy to start with emacs, but harder to find resources for upping your knowledgeConfiguring external packages to suit your needs took some effort. Nowadays most package doc is very good most of the time.Majorly keybindings, how configure everything and learning all popular packages.adapting to the "key chords"Lisp is pretty hard workIt takes a while to get used to its UX and terminology: how buffers, windows, and frames interact, the minibuffer/echo area.Navigation and searching of Info pages.Learning how to think about problems in a way that makes the solutions found in emacs make sense. Tons of historical nuance exists in emacs, compared to younger more modern alternatives like VS Code.I learned emacs in 1976 with Emacs written in TECO on ITS. So customizing emacs back then required writing in TECO, which was obnoxious and primitive. But no, using emacs itself was always easy -- as I gradually learned all relevant keybindings and learned how to look up the ones I didn't know, and then how to program in TECO, then MacLISP (Multics Emacs), and then Elisp (GNU emacs). I also used Epsilon on Windows way back when.none, but it was very hard to compile at the timeDisplaying inline images in png format in org-mode. The image was generated with tikz and had no background. Other png images with background would show normally, but the one from tikz without a background would not show. Giving the image a background solved the issue.Can't really remember.Moving from CUA, or windows shortcutsConfigure emacs. Need to learn elisp just to configure emacs.Very outdated keybindings Bare out of the box experienceInstalling emacs - specifically, a version new enough to support Doom Emacs - is a perennial challenge. Every time I have to install or upgrade, I spend at least an hour reading 3rd-party guides and wading through many competing distributions and installation options before finding one that works. It often feels like the documentation for both emacs and its key plugins were written so as to be crystal-clear to someone who already understands how that feature works. I bounced off both of these several times before some fit of frustration with PyCharm being buggy or something like that finally had me upset enough to push through and properly get started.Elisp is not easy unless you read a lot of documentation, thus customizing Emacs is kind of annoying at first (had the opposite experience with vim/neovim).working out what keystrokes to use. almost impossible to work out how to configure. if doom or spacemacs had been available when i started it would have been much easierEasy to assume packages being available = packages being REQUIRED/IMPORTANT. Learn at your own pace, start a few weeks on just the Emacs Tutorial (C-h t)Switching amongst buffers. In particular, C-x C-b is NOT the same as C-x b. That's nuts.Initial config, extensions and keybindings which meets some on my needs. Without the first 5 videos of Emacs From Scratch I would probably had give up.It was a long time ago, but I remember struggling/not really understanding the point of emacs until I started using Helm (later Ivy). Once I had a more visual completion framework, all the other pieces started to come together.Customizing themes/fonts/colors. Window/frame/pane manipulation.debugging a broken init fileWriting elisp to configure simple things was quite obscure.Understanding the difference between .emacs/init.el and custom.el files- Absence of manuals and references in my native languageUnderstanding variable bindingsI was accustomed to vim-style keybindings. Using evil & co would give me inconsistent keybindings throughout emacs, especially considering packages. The emacs keybindings are subjectively worse for editing text and took me quite a bit of time to adjust to. As a bonus, they also sometimes work in shells.defaults are uglykeybinds being cryptic, also functions under M-x not completing and things like thatIt was a bit slow on my Amiga 1200!Honestly not a lot (that I can remember). I know I went through the built-in tutorial, and just started using it.I didn't really understand how major and minor modes interacted with key bindings and this caused a lot of frustration. For example, in term-mode I struggled a lot with char-mode and line-mode. Thankfully vterm-mode exists now.This was a very long time ago. The biggest challenge was learning the Lisp...Using the wiki from the start was difficult: I started from videos before being able to understand itgetting the muscle memory down, putting Emacs in a state where I didn't know how to close or get back to where I was, downloading and installing packages manually, Trying to get features in Emacs to work in non unix environments (Terminal mode on Windows) etcI was pretty young, so I can't remember. I think I was used to CUA and I had to relearn the more commonly used keys.setting (and learning) some key packages as `paredit`, installing packages and keeping them updated, getting used to key bindings, and editing with 'latex'Installing packages, adding stuff to init.el. Learning the key bindings. Uncertainty with what packages work well together.Yes they have been plenty. I never found the vanilla Emacs keybindings natural, I chose Vim and only gave Emacs a serious try because a friend convinced me Evil was actually a close to the real deal, and because I realized Emacs could do a lot of stuff Vim cannot.Understanding and managing frame splitting, understanding the difference between minibuffer, help windows and new frames (e.g. when will 'q' dismiss? when will C-g? etc). Which terminal to use (ended up with vterm). Understanding themes.It was extremely difficult as a non-programmer to get my head around the .init file and basic configuration commands such as setq, bind-key and use-package.No, it was a long time ago...Understanding how sequential keybindings work.Learning bindings, how to get and configure new packages, and learning the concepts behind it (frames, buffers, etc.)It’s all mysterious until you learn elispKey bindings, file management, lsp language serverseemingly arcane key bindingsSteep learning curve, it takes time and tinkering to get something usable for work.Understanding which parts were actively maintained / worth learning.Getting used to keybindings and elisp config.Learning X-Emacs was not the one to use.Adapting to a "self-documenting" program took a while. Simply reading the Emacs source with 'C-h f' and 'M-.' wasn't something I considered when trying to debug configuration problems, as I'd never used software that encouraged it.Elisp configuration is kind of hardNone. Total immersion with the manual at hand, looked up everything I needed til I learned it.First streps in achieving what I intended without knowing the keybindings and names of functionsDefault bindings were not very intuitive or discoverable, had difficulty with the configuration/customization systemI’m still learning emacs after a decade. I think I had some trouble with getting it working out of the box.I struggle to memorize the keybindings, especially after time away from Emacs.I started with spacemacs, and once I had the basics down after a few years switched to a custom configIt was hard to understand many things. I was not sure what are "modes" and how emacs knows if I writing a "tex" document or an "org" document. I did not know how to install packages. I am still afraid every time I need to upgrade. I can understand only very little elisp. I am still lacking much understanding on emacs. I now use doom, and it helps a lot in getting the packages I want. I usually try to find examples of configurations from other people and tweak them as I want.I often struggled with the less-often use operators like grave (`), at (@), etc since they were difficult to Google and find an answer to. I still don't know what @ does. I also recall autoloading often confusing me as I was learning to write my own config, but once it clicked, it became my friend.Key bindings weren't easy to memorize and it wasn't exactly easy to customize back then. It didn't even have syntax highlighting, if I recall correctly. But it worked and did a great job auto-indenting C code.Finding features, so many packages so many different ways to configure them. Finding something amongst all the possibilities is difficult.Learning the keybindings and learning ELisp.How to start. Vanilla is too steep for a beginner to configure.A lot of packages, which makes writing complete config quite confusing. Better alternatives for major packages take time to get well known, like it was with corfu for exampleKey bindings - learning new shortcuts/terminology for simple things like copy+paste took time. Same for commands that require multiple keys (e.g. C-x C-f). Configuring everything using elisp instead of dialog boxes was a really steep learning curve.Learning keybindings, learning elisp/how to customizeStarted with Spacemacs, so a learning curve simply because of it. Then "unlearning" some vim-habits, but Evil makes that much less painful.It was hard to learn i remember had to put time and energy into learning how to use it, but it paid off.Code navigation (jumping to definition and back, etc)Complexity overload. But that's not really a bad thing, since that's part of why I love Emacs; it is tailored for power users. Setting up a proper config file can be hard, but doom Emacs helps with that. I think I had an easier time because I came from Vim, so I expected a steep learning curve.Difficult to follow the inbuilt tutorial learning key bindings default user interface is not nice took lot of time to learnDiscovering commands and bindings (which-key and orderless help a lot)Default key bindings are a bit wonky for someone coming from Vim keybindingsYes. There needs to be a basic intro that covers how to open a file, save a file, cut, copy and paste, search, help, basic moving around (CTRL - N,P,A,E, F, B), selecting text, centering the window (C-L), windows and the concept that it's ok to have 20+ buffers open at once in under 5 mins (maybe under a minute).Learning Elisp is very daunting for someone not too familiar with programming. Coming from Vim, configuring Emacs from scratch is a much more extensive task.I found it very hard. Took a week isolation in Sweden with nothing else to doI dove straight into doom eMacs so I had to learn the naming conventions of the commands as well as vim keybinds, it was a lot but worth itBreaking the mouse habit was difficult at first until I forced myself to only run it in a shell for three months.shortcuts, menu, explorartion of funtioality, cofigurationStruggles to manage packages in a functional way (I'm using leaf.el and I am pretty happy with it for now) Struggles to grasp the full meaning of a “buffer”. This is a mess at first (keeping buffers for every tab-completion I do was a very big turn off). It was a lot better after setting up vertico and friends though, and stopping to care. Generally, I think finding the right packages for a given task is not always that easy (the right one for me is one that plays with emacs builtin (such as vertico) instead of creating its own DSL where possible, having a modern and functional code architecture and is easy to configure in a declarative way). I wish to work with LSP or/and FlyCheck and friends but I still struggles to setup it and understand it correctly.the elisp languages, many keywords don't understandcommands requiring multiple key chord sequencesThere were two main difficulties. First, my professor gave us a cheat sheet, but it took a little bit of time to learn enough commands to be effective. The second is related. Because I didn't know all the commands that were available, I used emacs in a suboptimal way for a while. It took me a while to understand how to use buffers (at first, I had multiple emacs processes running, each with a different file, because that's what I did in other editors). And even though I've been using emacs for 20 years, I'm still learning about new functionality.key bindings, performance, language integrationLearning the keybindings and learning how to use built-in utilities were the biggest hurdles. I couldn't find any beginner-friendly tutorials for emacs back then. While I got through the first hurdle, I couldn't get the hang of learning about emacs through documentation (It doesn't seem very beginner friendly). I find myself looking up online documentation every once in a while to get to know more about emacs utilities.Being overwhelmed with configuration options, having to memorize keybindings to efficiently manipulate text as well as some minor performance issues.It was and is difficult to navigate through the Info menu. The built-in tutorials and guides suggest some thoroughly nonsensical things to fresh beginners, like navigating all text using C-(b|f|n|p). Emacs running outside of client/daemon configuration regularly hung, with no indication of how to enable debug stacktraces or allow Emacs to respond to SIGUSR signals.Understanding Lisp and trying to use it to customize Emacs was especially challenging in the beginning. The keybindings took a few days to get used to, but not a challenging hurdle.archaic key bindings, terminologyunderstanding lisp and emacs framework such as buffer, window, framewith only moderate knowledge of english i need more time to understand the documentationUnderstanding functional programming at last made a big difference in understanding ELisp.I mainly program in java and unfortunately there's no real good support for that.The documentation is not as good as it pretends to beyes, ecosystem is so big it was quite overwhelming, and as a new programmer I struggled with setup in elispAt the beginning, basic keyboard shortcuts (copy, paste, cut, delete ...) seemed unnatural. Also, I struggled with terminology. Buffer, Window, Frame, wtf ... where were my files?None, sorted most things with ddg.The archaic key bindings and terminology.Default shortcuts and concepts such as frame, point and window were weird.Just understanding some elispNon standard copy / past vocabulary and commands. The standard experience is not attractive at all and the mouse support is just bad and feels in contradiction of what makes Emacs good. Some obscure shortcuts are short while useful ones are often long (I don't understand why switching buffer is not Cmd+Number by default). There is no consistency in the vocabulary, especially verbs which describe actions. The Emacs manual is written with accuracy in mind but does not respect the reader's time. The editor is alive thanks to people who have a very specific and rigid way of thinking about the human machine interaction which is a paradox because it also makes it difficult to grasp it from the outside. Sometimes there is the mentality that newbies have to prove that they are worthy of using the editor and it's normal that it's hard at first. It's not discussed enough.Elisp was and is a significant barrier, probably partly because lisps are so different to anything I've used before.memorizing editing commands that involved key chords. That's why I gravitate towards evil-mode.elisp being rather archaic languageNot clear DocumentationDoom emacs makes the initial approach to emacs as painless as possible.Lack of a proper tutorial (like vimtutor), and no "beginner mode" which emulates mouse driven development in the style of vs code and clionLearning the key bindings, how to set up the editor to my needs (including 'best practices'), where to get helpOverwhelmed by optionsNeeding to know at least some elisp to customize itNon-standard keybindings relative to other text editors.At the very beginning, just remembering key combinations. It also took me about a decade of using Emacs to really understand the help system and to move beyond just copy/pasting Elisp code into my config.Steep curve. Tutorial is good. Org-mode provided motivation.Minor difficulty only: C-h is the terminal backspace and bothered me until I learned that everything is configurable.I struggled a lot with Elisp, and the strange keybindings.setting up emacs with custom font and getting rid of the ugly default uiRemembering all the Ctrl- Shift- Alt- keystrokesKnowing programming to customise itThe keybinds are very different compared to vim, and the whole thing feels slower and much less efficientWhen I was learning Emacs people were all like "oh but it's so extensible! The documentation is so nice" Unfortunately, there is no good tutorial on how to start extending Emacs. Documentation is mostly good for people who know what they are doing, as I'm finding out right now as I try to teach leaflet.js to a person who has never written any JavaScript.Just having to get used to it, it does a lot of things differently, so you need to get used to itToo much stuff doing the same job, init.el (at the time)It was long, long ago, but the concepts of the different key binding prefixes, which ones were pre-assigned and which ones were good choices for customization (because doing so wouldn't break some common but as yet unlearned capability) seemed like a frequent stumbling block.Scrolling around moves the cursor (got used to it now). Accidentally pressing an unwanted keyboard shortcut with extreme results, like deleting half of my document.Using Doom + Evil meant that I didn't have to actually understand how Emacs works. This has lead to the foundation of my Emacs knowledge to be spottyHad trouble with the default bindings before switching to evil1- Keyboard command sequences: take a vacation and you quickly forget them all. I would have favored if there was a clear relation between GUI elements and those commands, so that there is always an obvious secondary path. 2- Getting from vanilla up to an actually usable environment takes ... years, in my perception. This repeats to some degree when I switch programming languages. Every time it means experimenting until the experience is not distracting anymore. I would strongly favor readily available meta-packages that just create a basic default package with things one comes to expect. Or a setup thereof via "wizards" so that one can quickly assemble what is needed.Some key-binding conflictions when editing .emacs.dUnderstanding the keybinding notation: M-x,C-x,C-M-xElisps Brackets and lack of understanding how emacs works under the hoodIt was a very long time ago, but I suspect not "getting it" in terms of discoverability: cargo-culting elisp without the realization I could discover this functionality for myself.It's been a long time now, but I do specifically remember wanting to customize the appearance a bit, and especially wanting to change (what I now know to call) faces. I found this difficult, mostly because it required concepts I didn't understand yet from my previous computer experience (I was used to "choosing a font" in proprietary GUI programs and desktops), and I don't recall seeing anything in e.g. the tutorial that helped me.Understanding evil-mode internals to customize itLearning key bindings, navigationI would look for online fixes, and they wouldn't work.learning keybindings was a wild ride.Unlearning keybindings, and debian separates documentation in non-free so I didn't know that it existed.setting up configuration filesProbably remembering the key bindings coming from a then Windows background. I prefer Emacs keybindings though, keep them.Key bindings. Not insurmountable. But it was weird at first. Flipping caps lock into a ctrl key was a big moment.takes a while to learn, but nothing stands out as a difficulty.Elisp is quite difficult to understand as a beginner, I definitely stopped using Emacs for a bit because I felt like I hit a wall with the names of variables used to configure Emacs and how those settings were set in Elisp from StackOverflow posts. I also remember finding the manuals quite dense and difficult to find the right information about key bindings and features that I wanted. To this day I don't know how to navigate the manual in editor, and I install packages like which-key and helpful to tell me what's available to use.Non standard terminology. Should not start with vanilla emacs.- Getting used to accessing the context menu for commands rather than (coming from vim) :SomeCommandOrOther. - Learning how to write kbd mappings for frequently used commands.Discoverability. But that has changed A LOTThe keybindings.basic key combinations, I still tend to mouseUnderstanding how to configure emacsSetting up emacs to make it usable was quite a challengeThe commands are different than a Windows editor but it works much closer than vi so I've always used Emacs.Poor experience out of the box, needed extensive configuration just to get things like completion working to my liking.If you glance over anything while starting out, it can feel really daunting to approach emacs. I feel like the general sentiment that users should start with basic emacs in order to understand it doesn't work well for a lot of people. I wanted to try out emacs to learn some lisp, and see how it compared to vim. The initial experience was pretty slow and felt clunky, but after switching to spacemacs, then doom I found my sweet spot. For users like me, something like doom gives the starting point to be productive from the start, while maintaining enough of vanilla emacs's performance to feel great. Starting off with that stable base allowed me to explore more of the configuration, build out test code in a literate config, and generally encourage experimentation due to the reduced risk of destroying your configuration. Something like emacs koans to give people a quick start with exposure to the core concepts would also help lower the barrier for those curious to try out emacs & get some of the real experience.I'm still learning and it's still difficult. But specifically, the lack of defaults, especially when they're different from current standard (copy-paste for instance). And explaining this away with "this is the Emacs way" isn't exactly helpful.- Before I switched Caps Lock and Ctrl, I found the bindings very unpleasant. - I recall struggling to understand the M- notation (and am still confused about the difference between M- and Alt-). - Was used to standard Windows shortcuts for saving/quitting, etc. But I now appreciate the Emacs key bindings and would not wish to use Windows-style.You learn on the go and explore more and moreJust getting started. The out-of-box experience isn't great.I found the self documentation of Emacs to be good but not well organised. I mostly learnt from screencasts, but would have definitely read the documentation much more if the organisation was better. To be specific, the documentation throws everything at you or in some cases leaves out a lot which might have been interesting to dig deeper.default completion system is not good when I first use emacs (28.1)Discoverability of (3rd party) features-as-packagesI used microEMACS in the early 1990s. I stopped using it after learning vi on FreeBSD. In the past five years I took up EMACS to use org-mode. I won a copy of Learning GNU EMACS at a UNIX users conference where I chatted with Richard Stallman. I can’t use EMACS without evil mode. It’s annoying to lookup how to close a debug window and then search how to fix what is usually some package incompatibility. I’ve tried to set up org-roam but there’s some strange (timing?) bug that stops it initialising in macOS. Works fine in Windows and FreeBSD. One day I’ll take the time learn how to debug elisp code. I try the GUI version of Emacs from time to time but find it has a disconnect with the X-Window, Windows, or macOS graphical environment so back the shell version. I worked for years using twm in X-Window running four xterm windows and occasionally Xpdf, xv, Firefox and sometimes OpenOffice. I own a commercial release of OpenOffice. I find EMACS with packages I want to try very flakey compared with vi (not vim). Setting up the meta key is always an issue. I can’t use SpaceEMACS. Space in vi has the same action as Ctrl/f in emacs and redefining the Space key replacement is tricky. I don’t think I’ve ever tripped a bug in FreeBSD’s vi in 25 years of use but I don’t extend it in any way. I’m used to working with flakey software.Elisp itself.Documentation eccentricities like using "which see" everywhere. The documentation is hyperlinked, just link to it and describe it instead of using 1:1 translations of latin in the most awkward way possible. Or just use `q.v.` like normal people. Documentation in general. Should always be in a lispy form (eg why do commands and functions omit parens?). Should have more real examples you can execute right there to see it work. This only makes it harder for people new to elisp.Creating my own configuration was a bit of a chore due to my unfamiliarity with elisp. Bugs were also a bit difficult to resolve because of this.Configuration is trickyCan't rememberAt the time, some Emacs versions I had access to had bad UTF-8 support. At least by default it would not deal with that very well. In general, Emacs is so different from anything else, hence learning it has high friction.I disliked the frequent use of the hard-to-press ctrl and alt keys. I also found unfamiliar terminology confusing."undo" as in ctrl-z is not the same in linux terminal; breaking that habbit was a no-go; then later overriding said keybinds and attempting tweaks ~/.emacs.d/init.el was a learning experience (as opposed to "dropping-in" somebody elses blob-of-codeSo many features!* Help system was hard to access * It took a while to build muscle memory for the keybindings, but I'm now very efficient with itevil-mode and doomemacs helps a lot, but i still find myself reaching for s instead of c too often. nix-doom-emacs is amazing, a true labor of love.Lisp, dense documentation, lack of knowledge of how editors workedI was trying to learn too many things about Emacs at the same time.Documentation Navigating on how to do whatRemembering keys, wierd vertical and horizontal movement, finding functionality.Learning new key bindings- It's easy to install any package you want, but it's difficult to know which packages conflict with one another. If you're not careful with a version controlled .emacs.d, then it's easy to get into an irreversible broken configuration.chorded bindings being unfriendly to fingersIt was very difficult to use Vanilla Emacs (which I did for my first 4 of 6 years). Doom Emacs is much easier to get started with.Shortcuts. It was confusing to choose meta-x or ctrl-x.It’s default set up was unapproachable so I used first space macs then soon after doom eMacsI had issues with native compilation, emacs 28, at first but homebrew for my Mac and the fedora packages made it very easy in due time.Getting started in lispDebugging what was going on, nowadays I simply run a buffer that logs all commands that were run by Emacs.This was too long ago to be of any relevance, and I think most of them no longer apply anyway -- e.g. compatbility problems between GNU Emacs and XEmacs (but GNU Emacs didn't have packages...).How to configure emacs.. Elisp sucks..In the beginning it was hard to figure out which packages to rely on. Often there are multiple options for solving the same problem: eg. ivy vs vertico, corfu vs. company + company boxElisp is terrible to learn and use. Lots of emacs defaults are not good, so you have to do a lot of modification in elisp.Gettings Emacs to understand the structure of my project(s) was not easy. Now, with LSP-based server like clangd, things are much easier.Keybindings were not a thing I had ever thought about so I had a pretty hard time with figuring out how to use e.g. buffer switching. I am still having issues with everything being a buffer, especially when I want to e.g. fetch data from an API, I just want an alist that I can work with instead of having to figure out where the content begins and ends in a buffer.It felt like there were too many choices in setting up a more IDE-like editing experience.i missed a flexible learn approach designed inside/as-part-of emacsMaking the switch from Vi like editors due to bindings. The greater challenge was the absurd codebase size. I tend to audit my programs, so I still find it hard to use emacs due to the amount of unnecessary code that comes with most distros versions. I've long dreamed of retiring and offering my services full time to help minimise and secure the emacs codebase.I still struggle with buffer management and Dired configuration.Hard to learn the unusual bindings, and I had never programmed lisp. Interface does not look user friendly for a beginner.learning keybindings- Since I do not use Emacs all the time, I often forget shortcuts or how things work and have to look it up again. - Since Emacs uses a very peculiar terminology, it is very hard to search for problem solution on the Internet, because one has to know the terminology to do so effiently. - The biggest shortcoming of Emacs is that it cannot navigate Windows symbolic links to documents and directories. This is the reason, I do not use it except as an editor for GIT and for a to-do list with org-mode. In all other cases, where I need to navigate the file system to load files, I use other editors, that can follow symbolic links.Remembering keystrokes was a pain initially, but muscle memory means nowadays I just press the keys without thinking about it.it's really damn hard to learn this alien landscape that relies on shortcuts. but it was worth it to get through it. i tried for years before it finally took hold. it was frustrating to lose my work and not know how to easily put my ideas into text as easily as in text programs that use normal conventions (like kde kate).- Bad GUI performance, especially scrollingRemember key bindFeature discovery, keybinding discovery.fretting over the default bindingsconfusing interface designLack of proper multi-threading means I still have occasional problems where everything locks and I can't do work. But that may be more due to all the things I do in Emacs (email, rss, mpd, journaling, coding)Finding help and keybinds in terminal version on older emacs, didn't know that F10 can bring down the menuThe buffer/window/frame thing was hard at first. Keyboard was fine as I was learning on Solaris and had a proper keyboardMemorizing default packages, its bindings & global bindings.Not as a basic editor. But I didn't understand Elisp and was new to programming in general, so I couldn't customize it.Multiple ways to change variables, some endorsed and others not. For example there's documentation in doom that says, "don't edit themes / faces using Easy Customize" (or whatever it's called). Since I started with Spacemacs instead of vanilla emacs, I didn't know which features belonged to packages and which belonged to emacs.Lack of easy tutorials for non-programmersremembering bindingsSome functionality relied on external programs not available on Windows.New bindingsConfiguration was insanely hard at first.What I call the "pre-mouse era" UI paradigm: frames vs. windows, normal cut/copy/paste key combos don't work without configuration, stuff like that. Also the fact that buffers are first-class citizens rather than an implementation detail takes some getting used to -- in most "modern" editors one tab or window == one file and closing that tab or window means closing the file, so the idea that you can keep the same windows open and just put different files/buffers in them or keep a file open even though it's not displayed in a window anywhere, while powerful, can increase the initial cognitive load.corruped docstringsThe key-map was very different compared to Elvis (vi-clone) that I used before and the C-X B and C-X C-B functions was very different to the :bb buffer list in Elvis. Once I got used to them I had no issues.default key binding is a bit weird, especiall about Control-H. (I'm always swapping Control-H and DELETE)Default keybindings. Knowing about the packages that could help me. Software project consistency: same behaviour in Python, Scala, R, ...Yes, it's a completely different editing paradigm from most, e.g., Ctrl-X, Ctrl-V, etc.It was common at that time but the shortcuts seemed to lack some structureConfiguring to my liking. Huge amounts of config code needed and difficulty getting packages to play nice. Settled on outsourcing to spacemacs which was a compromise - somebody else did the work but it's not lean and frequently ran into upgrade problems.Mainly breaking changes between versions of Org, etc. There is a need to be always tuned for the latest news, which is not that great while we are still learning.Buffers vs windows vs frames terminology. Getting past copy/pasting elisp for configuration--learning about describe-function and describe-key enormously improved my understanding of emacs.keybindings were problematic at first, I got used to it in a month.Does not integrate with os well, no ctrl-c,vThe initial setup feels like it's missing a lot of things, spacemacs and doom solved thatnalearning elispSteep learning curve with different shortcuts for everything and specific idiossincrasies of it's age.Managing packages in a portable (syncing between multiple machines) manner.keybindings were hard to remember. kept get lost inside help buffersTime- emacs documentation is not written in "normal" programming terms - elisp is extremely difficult - emacs is not using "normal" terms for some common concepts/operationsCan't remember the keybindings. Saved the configuration, but it doesn't take effect.elisp. It's still hard for me to write init.el. Functional programming language is hard for beginner, syntax and semantics are still facing for me.(e.g. Dynamic scope is a pitfall). and, most important thing is, Lack of elisp documentation for "modern emacs". I googled elisp, there are so many too old code snippets,I can't find out "right way, right style" for now.Lisp was not very intuitive at firsrDefault configuration isn't great and it's difficult to customize as a new userEmacs' default keybindings for copy/paste, so eventially I've set up CUA mode and I still use itNo. Coming from Vim I was already used to arcane key bindings.Learning the editing keyboard shortcuts, learning elisp well enough to effectively configure emacs, doing extensive configuration to make things work the way I like.Configuring C-mode to use tab indent with 4-char wide tabs. Have since converted to just spaces.Initial configuration, which solved by Doom EmacsCustomisation is not intuitive. Discovering functionality via help is also not that easygetting to a point where I could code like I did in vscode. highlighting, formatters, completion tools are all packaged separately for working with typescript/react where vscode kind of figured out what was best to start you off.Cryptic documentation Unintuitive keybindings Elisp quirks* hard to tell at which point loading a broken config fails ** a KILLER feature would be more clearly showing the exact point in the init where loading failed, for people who haven't learned even basic lisp reading / the debugger yet * shortcuts * integration into Windows (installed into "weird" paths, trouble with environment variables?) * couldn't easily find true beginners tutorials (today there are lots of for example "0 to org-roam" articles)Behavior is very difference from typical text editor.Memorizing chords. There was no recognizable rhyme or reason to the choice of key combinations, and too many to memorize quickly.Default KeyBindingsDifficulty to switch Control and CAP LOCK on Windows.I had issue (still have, really) finding a conceptual map of the built-in functions emacs offers. I think a lot of libraries like f are used not just because they are thorough, but it's easier to install them than it is to discover the list of built-in alternatives.Knowing where to start, learning the "modern" way of configuring XYZIntegration with language tooling (has improved with LSP), lots of functions, and I still struggle with the default keybindings (evil user)i know i had em but i don't rememberDefault config was really bad compared to other test-editors and what is possible with a bit of tweaking: Ido for example was one the package that made the experience way better.Trying to get my head around Lisp syntax and errors when writing init files (as much as I love it now).Buffer vs window and general naming differences. Why ctrl shuold be a leader never made sense before i got the capslock setting. Evil keys not always working in some minibuffersunderstanding best practices. There are so many possible workflows (like, are you using Emacs just as a text-editor to edit random files and save, or as a full-fledged IDE that does code-completions/suggestions and compiles into its own runtime... maybe all of the above while ssh'd into a remote machine, or within a docker container etc) and it feels like there are ad-hoc ways to set all of these things up, but it's really hard to figure out the *best* way, or the most-compatible way, or the most emacs-y way. This extends to using emacs as an organizer with org-mode. You can put a calendar and db of contacts etc in it, but what are the most integrated, compatible ways of doing it?Lisp was different than other languages I'd worked withuse some one 's dot filesWhen I first tried Emacs I was turned away again by the key chording (ca. 1990s). Now, while relearning with Doom, mostly how to open files in the gui / my terminal running in parallel / manage the emacs server and using GUI vs. Terminal version.Elisp is not easy. Don't remember specific problems.Documentation was hard to follow, configuration requires relatively extensive knowledge, dired is confusing (It still is).Not being readily available/packaged with OSThe built-in tutorial was helpful but too Barrow in scope. Understanding what Emacs is and what the different frameworks are (e.g., doom)Very many packages to use, analysis paralysis. Similar sounding packages. Initial temptation to bounce off due to default look and feelOne difficulty with learning Emacs was learning elisp. This was my first experience writing lisp and coming from C-like languages it was difficult to pick up. Another difficulty with learning Emacs was learning how buffers work in Emacs. This includes managing and selecting buffers.I used spacemacs without bothering to learn elisp, and that caused quite a bit of heartburn. I remember frequently shutting down emacs because the evil keybindings layer had failed, and I never learned the various emacsy escape hatches for fixing whatever had gone wrong.I found hard to understand how I should use emacs correctly, like how to look for information inside emacs, how yo properly customize. I think it took me some time to find out there was a tutorial and the C-h+[a-z] keybindings. I tried to use emacs 3 or 4 times whithout success because it was a bit difficult to remember keybindings and how it should work.Trying to achieve too many things at once; using elisp snippets from the web without understandingGetting used to the keybindings scheme of emacs has been the most difficult aspect for meLack of internal documentation (how do I do ___), which has since been greatly improvedKeybinding and configurationMy difficulties came from following other people’s shiny config and not learning the system itselfcannot use out-of-the-box... everything? :-o symbols in lisp error messages in lispEmacs doesn't have as easy of an out of the box experience as some other editors. Getting intelligent auto-completion was one of the first tasks I found challenging (this was before lsp/eglot were as popular as they are now). Additionally some basic stuff like changing the font requires more knowledge than some other editors.The require system was slightly confusing to learn. I mistakenly thought it was only for 3rd party packages and didn't know that autoloaded functions don't need to be required.No experience in using lisp, so felt hurdle in customizingThe documentation for emacs often assumes I know things that I don't know. There is no directed acyclic path through the documentation. Some of the referenced concepts take several days of learning and experimenting to understand. So, yak shaving is common. Even when I set aside time to learn part of emacs, I struggle to know if the thing I'm currently studying is the "next" part of emacs I should be learning, or if I learned a different package, or data-structure, that would help me learn the current subject faster. For example, right now, I'm assuming that Char-table's are an obscure type of array, that I don't really need to understand. So, every time I see documentation for a char-table, instead of redirecting into "learn char-tables", I'm assuming that I don't need to understand them to do what I need to do. But, that's a guess, and I there are many other topics in emacs that I'm treating the same way, because I don't have the time, bandwidth, or intelligence to learn it all at once.The helpWeird key bindings.write elispSteep learning curve and then getting familiar with the bindingsnot really...Keybindings, package managment.
If you wish to contact the package maintainer(s), how do you do so? Vector{String}GitHubEmailMailing listI don'tn/aN/ADiscordI don’tI dontIRCircI don't.Never havenonei dontNeveri don'tnever haveNonedon'tNADon'tTwitternoI've never needed toI never haveNever didredditI do notRedditGitlabNever needed tonevernever had toi haven'tNever had toI don't know-I've never triedNever contactednotMatrixI have never done thisCodeberghaven'tsocial mediaHaven't done itNever done soThis has never happenedHave never done soI've never done thishave not done soSlackDiscourseI don't think I ever haveI've never contacted a package maintainerNo contacttwitterNever triedNever done itI don't have the time for that. If it doesn't work in some way, then it doesn't work.I’ve never contacted maintainer(s)I don’t contact themrarely do thisI never have but I guess I would use githubWhatever way they prefernullHN comments if they do a show HN or somethingI've never needed to do so, N/AI don't, sorry!I have never done soHave not done soNo idea. I haven’t tried yetI have never had toas requested by maintainerNever felt the need to do soCry myself to sleep, and pray to my godsHaven't done thisI never have, maybe I will in future.I don’t wish to contact themI use vimDon't knowMatrix serversNever doneI don't contact maintainersnot happened yetvia the method mentioned in the README of the projectnever happenedHas never happened in 17 yearsI generally don'tdon't really.Depends on what they wantI have never done so.haven't yetfollow the method specified by the package maintainer.I never have.bug reports; depends on the packageHave never tried!mastodonI never dochoose not to bother them with my stupid questionsask colleaguehave notI don't b/c I usually assume the problem is with meGitHub issuesdontNever the mailing lists stop using email for goodness sake.Discord/slack if availableComplain on some obscure corner of the internet. I'm sure it eventually gets back to them...uninstall packageWhatever they wantNever done dlsonever done thisIRC, XMPPI have never tried to contact a maintainer so farWhatever preffered form of contact is listed on their GitHub/Gitlab/whateverI'll check what are their preferencesNever thought about itI don't contact maintainers.Never contacted a package maintainerNaI don't most questions I have are usually answered on various foramatrixI don’t generallyhave neverother git hosting platformsIt hasn't occurred in a very long time.Haven't done that muchOther repositorywhatever they have indicated as preferredGitnever done thatAccording to their preferencewhatever the maintainer prefersWhatever their prefered contact method is (like Reddit or whatever)Depends on what they request.Dedicated issue tracker, often hopefully not on Github™preferably email, but if unavailable, I'd do it via GHAny way the package maintainer prefersUnsuredon't contactDoom Emacs Discord and the channels #emacs and #doom-emacs on the Clojurians Slacln/a (I don't use packages)These days, mostly Gitlab. Occasional chat on Mastodon. Some comments and discussions on Reddit.Carrier pidgeonNever did thisPublic git repositoryTwitter depending on contextIRC, other git forgesi will fork the package insteadI never do.I don't, generally.LIBRE Source forges such as Codebergi don't reallywhatever forge the maintainer useslist-package details provides a website that is often the repository.Doom Discordwhere requested in their readmeknock on their doorfuck you for making me answer this, you said I didn't have toI haventhaven't done this yetNever wished toHaven't needed to contact themI don’t ever contact themnot contacted any maintainers yetN/A but I'd prefer to contact them via email or maybe a mailing listWebnever needed to contact maintainerTelepathyI wouldn'tnever done soI don't. I really should but i just dont...not github -- it is hostile to FOSS now with the new ownerHavent need ithave not tried to contact themi usually don'tI don't. I just don't use it.Discourse or Discord sometimeshave never done thatWhatever they specify as the contact option. Not always Github!Never consideredHave not done that yetGitHub (unfortunately, because most of the repos are hosted there)Git*. Many are on GitLab, Source Hut, or other alternatives.?Use whatever the maintainer indicatesHave never contacted package managertry to look up which method they preferI fix it myselfdiscord/slackwhatever authro prefersI didn't have any need to contact them yetSocial MediaI don’t find that usefulHaven't contacted package maintainersAgain, not a question for me.I prefer to stay anonymous and have no wish to contact package maintainersNaNHave not been in this situation yetmatrix, ircwhere I can find them.I don't because I'm incredibly shyDoom discordThe need has never arisenNever had a needDon’tI don't. If I have a problem I cry for the tragedy of the Lisp machine and hope for a better world.Haven't needed toNever have beforeI don't (I don't feel legitimate enough)whatever forge he is usingnever needed yetany git service or issue trackerI do not contact themGNUnever contactedpackage maintainer's preferred methoddepends where I find themnever triedI have never contacted package maintainersnever did itnever did so i thinkWhy would I do that?Package's issue trackerDepends on the package and maintainer.issue tracker on whatever forge they are usingI have never contacted the maintainer of a packageNever contacted any.provided contactI have never done itFile a bug at debugs.gnu.orgI avoid mailing lists because of spamI have not contacted a package maintainer.anything the maintainer wishesNot tried yetNever did thatAbout time we ditch the mailing listsDiscord if possibleI don't?so far nodont know, has not occurredI don't contact themNever had to do soNot needed toDon't botherDo not use packagesI have never been aware of packages, much less their maintainers, or had the wish to contact such a person.I have to be truly desparate before bugging a maintainer and haven't done this in many yearsHaven'n contacted anyone, so I don't know without searchingtgI have never felt the need to do soFediverse, IRCeHowever it applies to package, but I mainly search available contentIM (usually IRC, Telegram or Matrix)Never done thatxNever haver, probably GitHubsignal fires from mountain topsIn a manner they publicly expressI have notDiscord, Matrix, GitterGitlab or any of their own hosted platformDiscord, Redditusually, I don'tDiscord,SlackTwitter if availableN/adon't knowGitHub, but would prefer free alternativesDon't contactI don't wish to contactpackage maintainersno such wishdon't contact maintainersI have not done so yetdont!Haven'tnot requiredContact other users if issues occurWhatever the package maintainer suggestsdeep sea octopusNever done so, so not sureNever contacted anyDiscord.gitlab, source-hutHaven't done so yet.Haven't so far, but probably Github or E-mail if neededDependsI never didDebian bug reportnaThis has never come upI haven't needed toHaven't done socursing at the winddependsNot applicableI never contacted a package maintainer so farNever contacted.Don't know what a package isEmacs-ChinaTo this time, I have not so wished.Never have. I would use email.Hasn’t come upWhatever the defined channel for the package iscomments on social mediaIf?.right now I am intentionally not using packagesI would neverI don’t generally and try to hack the package to my needsWhatever they're onN/A, I haven't had the need to yetNever doNotIRC or git repository, primarily.Call'emdpendsthe built-in bug report facility - email, maybe?I don't need toi haven't yetwhy not elpa / melpa?I never dared to contactHowever they indicate is the best wayI have never contactedUpstream repositoryI have not had to contactWhatever the package maintainers appear to use.never needed toBug reporthavent ever needed toI hate mailing lists, they are pretty outdatedI don't contact pacakage maintainersI haven't contacted anyone so far.However they ask to be contacted.I do not use packages anymorei have not wished to do sowhichever they seem to preferi prefer irc over the restI haven't, but I may mailWhatever the preferred contact for the package isChat room, if availableIrcgitlabIRC,MatrixI would not contact the maintainer.GitLabno contactI open an issue (on Gitlab/Codeberg/sr.ht/etc.)Never done thisGitterDepends on their contact preferencesNever do soI give up and move onHowever they track issuesi do notSlack, etc.I don't, the community is awful and it's like pulling teeth to work with open source software people (they are insane zealots) ... I will just either write my own package if I can't be bothered to fix theirs or just find an alternative (or move on). I am not being paid to be someone else's QA, engineering, and support teams.I don't wish thatI don't, why is this question requiredWhatever way makes senseI have never had that needI don’t bother maintainersI haven't done thisnever done this before
Do you contribute to Emacs packages? StringNeverRarelySometimesOftenFrequently
How well do you think this survey platform works? StringGreatOkNot great