Here is my (somewhat) simple Doom Emacs config

bindings.el

;;; ~/.doom.d/bindings.el -*- lexical-binding: t; -*-

(map! (:map override
        (:after evil-snipe
          [remap evil-snipe-s] #'evil-replace-with-register
          [remap evil-snipe-S] #'replace-to-end-of-line)
        :m "<C-;>"           #'goto-last-change
        :m "<C-'>"           #'goto-last-change-reverse
        :nv "C-]"            #'xref-find-definitions
        ;; dired
        :nv "-"        #'dired-jump
        (:prefix "C-x"
            :nv "C-b"  #'+ivy/switch-workspace-buffer
            :nv "C-k"  #'evil-delete-buffer)
        :nv "U"        #'undo-tree-redo
        :nv "J"        #'evil-forward-paragraph
        :nv "K"        #'evil-backward-paragraph
        :nvi "C-s"     #'swiper
        :i  "C-v"      #'evil-paste-after
        ;; macros
        ;; :n "Q"         #'marble/q-macro-test
        ;; :v "Q"         #'marble/q-macro-visual
        ;; text-objects
        :textobj "b" #'evil-textobj-anyblock-inner-block #'evil-textobj-anyblock-a-block
        ;; resizing
        :nv  "M-h"    #'move-border-left
        :nv  "M-j"    #'move-border-down
        :nv  "M-k"    #'move-border-up
        :nv  "M-l"    #'move-border-right
        ;; general
        (:prefix "g"
          :nv "k" #'join-line
          :nv "j" #'evil-join)
        :nv "C-j" #'evil-mc-make-and-goto-next-match
        :nv "C-k" #'evil-mc-make-and-goto-prev-match
        :nv "C-h" #'centaur-tabs-backward
        :nv "C-l" #'centaur-tabs-forward))

(map! :map dired-mode-map
      :nv "h" #'dired-up-directory
      :nv "l" #'dired-find-file)

(map! :leader
      :nv "/" #'+ivy/project-search)

config.el

;;; $DOOMDIR/config.el -*- lexical-binding: t; -*-
(load! "+bindings.el")

;; MacOS is weird
(use-package! exec-path-from-shell
  :init
  (when (memq window-system '(mac ns x))
    (exec-path-from-shell-initialize)))

;; Global modes
(+global-word-wrap-mode +1)
(global-set-key (kbd "C-z") 'undo)
(defalias 'redo 'undo-tree-redo)
(global-set-key (kbd "C-S-z") 'redo)
(add-hook 'prog-mode-hook (lambda () (interactive) (undo-tree-mode)))

(setq doom-font (font-spec :family "Fira Code" :size 14))
(setq doom-theme 'doom-monokai-classic)
(setq org-directory "~/org/")
(setq display-line-numbers-type t)

;; Proper indentation is always 2
(setq-default tab-width 2)
(setq-default js-indent-level 2)
(setq-default typescript-indent-level 2)

;; Never ever use tabs
(setq-default indent-tabs-mode nil)

;; No confirm on quit
(setq confirm-kill-emacs nil)

;; Which-key settings
(after! which-key
  (setq which-key-idle-secondary-delay 0)
  (setq which-key-idle-delay 0.2))

;; Configure scrolling
(setq scroll-margin 18 scroll-conservatively 0)

;; Substitute motion
(use-package! evil-replace-with-register
  :init
  (defun replace-to-end-of-line ()
    (interactive)
    (evil-replace-with-register nil (nth 0 (evil-motion-range #'evil-last-non-blank)) (nth 1 (evil-motion-range #'evil-last-non-blank)) (quote inclusive) nil))
  :config
  (setq evil-replace-with-register-key (kbd "s"))
  (evil-replace-with-register-install))

;;
;; Here lies my bad ivy config
;;
;; (setq ivy-sort-matches-functions-alist
;;       '((t)
;;         (ivy-switch-buffer . ivy-sort-function-buffer)
;;         (+ivy/projectile-find-file . ivy--sort-files)))

;; (defun ivy--sort-by-length (_name candidates)
;;   (cl-sort (copy-sequence candidates)
;;            (lambda (f1 f2)
;;              (< (length f1) (length f2)))))

;; (defun ivy--sort-files (_name candidates)
;;   "Sort CANDIDATES files alphabetically ignoring trailing slashes.
;; Meant for use in `ivy-sort-matches-functions-alist' so
;; directories will have a trailing /, ignore it so foo.txt is after foo/."
;;   ;; Perhaps add a check for if directories should sort first
;;   (cl-sort (copy-sequence candidates)
;;            (lambda (x y)
;;              (string< (if (string-suffix-p "/" x) (substring x 0 -1) x)
;;                       (if (string-suffix-p "/" y) (substring y 0 -1) y)))))

(after! ivy
  ;; (setq counsel-find-file-ignore-regexp "\\(?:\\`[#.]\\)\\|\\(?:[#~]\\'\\)|node_modules")
  (setq ivy-re-builders-alist
        '((counsel-ag . ivy--regex-ignore-order)
          (counsel-grep . ivy--regex-ignore-order)
          (swiper . ivy--sort-fuzzy)
          (t . ivy--regex-ignore-order)))

  ;; Better ivy sorting algo (more like fzf)
  (defun ivy--sort-smart (str)
    "Build a regex sequence from STR."
    (if (string-match " " str)
        (ivy--regex-ignore-order str)
        (ivy--regex-fuzzy str)))

  (defun ivy--sort-fuzzy (str)
    "Build a regex sequence from STR."
    (ivy--regex-fuzzy (replace-regexp-in-string " " "" str)))

   (defun ivy--sort-by-len (name candidates)
    "Sort CANDIDATES based on similarity of their length with NAME."
    (let ((name-len (length name))
          (candidates-count (length candidates)))
      (if (< 500 candidates-count)
          candidates
        (seq-sort-by #'length
                     (lambda (a b)
                       (< (abs (- name-len a))
                          (abs (- name-len b))))
                     candidates))))

  ;; Change the default sort function to rank matches according to similarity
  ;; with input text.
  (setf (alist-get 't ivy-sort-matches-functions-alist)
        #'ivy--sort-by-len)
  ;; No sorting for `counsel-yank-pop' as candidates are already sorted.
  (push '(counsel-yank-pop) ivy-sort-matches-functions-alist)
  (push '(counsel-recentf) ivy-sort-matches-functions-alist))

(defun copy-file-path (&optional @dir-path-only-p)
  "Copy the current buffer's file path or dired path to `kill-ring'.
Result is full path.
If `universal-argument' is called first, copy only the dir path.

If in dired, copy the file/dir cursor is on, or marked files.

If a buffer is not file and not dired, copy value of `default-directory' (which is usually the “current” dir when that buffer was created)"
  (interactive "P")
  (let (($fpath
         (if (string-equal major-mode 'dired-mode)
             (progn
               (let (($result (mapconcat 'identity (dired-get-marked-files) "\n")))
                 (if (equal (length $result) 0)
                     (progn default-directory )
                   (progn $result))))
           (if (buffer-file-name)
               (buffer-file-name)
             (expand-file-name default-directory)))))
    (kill-new
     (if @dir-path-only-p
         (progn
           (message "Directory path copied: 「%s」" (file-name-directory $fpath))
           (file-name-directory $fpath))
       (progn
         (message "File path copied: 「%s」" $fpath)
         $fpath )))))

init.el

;;; init.el -*- lexical-binding: t; -*-

(doom! :input
       :completion
       company           ; the ultimate code completion backend
       ivy               ; a search engine for love and life

       :ui
       doom              ; what makes DOOM look the way it does
       doom-dashboard    ; a nifty splash screen for Emacs
       hl-todo           ; highlight TODO/FIXME/NOTE/DEPRECATED/HACK/REVIEW
       indent-guides     ; highlighted indent columns
       modeline          ; snazzy, Atom-inspired modeline, plus API
       nav-flash         ; blink cursor line after big motions
       ophints           ; highlight the region an operation acts on
       (popup +defaults) ; tame sudden yet inevitable temporary windows
       pretty-code       ; ligatures or substitute text with pretty symbols
       tabs              ; an tab bar for Emacs
       treemacs          ; a project drawer, like neotree but cooler
       vc-gutter         ; vcs diff in the fringe
       vi-tilde-fringe   ; fringe tildes to mark beyond EOB
       workspaces        ; tab emulation, persistence & separate workspaces

       :editor
       (evil +everywhere); come to the dark side, we have cookies
       file-templates    ; auto-snippets for empty files
       fold              ; (nigh) universal code folding
       (format +onsave)  ; automated prettiness
       multiple-cursors  ; editing in many places at once
       parinfer          ; turn lisp into python, sort of
       rotate-text       ; cycle region at point between text candidates
       snippets          ; my elves. They type so I don't have to
       word-wrap         ; soft wrapping with language-aware indent

       :emacs
       dired             ; making dired pretty [functional]
       electric          ; smarter, keyword-based electric-indent
       ibuffer           ; interactive buffer management
       undo              ; persistent, smarter undo for your inevitable mistakes
       vc                ; version-control and Emacs, sitting in a tree

       :checkers
       syntax            ; tasing you for every semicolon you forget
       spell             ; tasing you for misspelling mispelling
       grammar           ; tasing grammar mistake every you make

       :tools
       ;;ansible
       ;;debugger          ; FIXME stepping through code, to help you add bugs
       ;;direnv
       docker
       ;;editorconfig      ; let someone else argue about tabs vs spaces
       ;;ein               ; tame Jupyter notebooks with emacs
       (eval +overlay)     ; run code, run (also, repls)
       ;;gist              ; interacting with github gists
       lookup              ; navigate your code and its documentation
       lsp
       ;;macos             ; MacOS-specific commands
       magit             ; a git porcelain for Emacs
       ;;make              ; run make tasks from Emacs
       ;;pass              ; password manager for nerds
       ;;pdf               ; pdf enhancements
       ;;prodigy           ; FIXME managing external services & code builders
       ;;rgb               ; creating color strings
       ;;terraform         ; infrastructure as code
       ;;tmux              ; an API for interacting with tmux
       ;;upload            ; map local to remote projects via ssh/ftp

       :lang
       ;;agda              ; types of types of types of types...
       ;;cc                ; C/C++/Obj-C madness
       ;;clojure           ; java with a lisp
       ;;common-lisp       ; if you've seen one lisp, you've seen them all
       ;;coq               ; proofs-as-programs
       crystal           ; ruby at the speed of c
       ;;csharp            ; unity, .NET, and mono shenanigans
       ;;data              ; config/data formats
       ;;(dart +flutter)   ; paint ui and not much else
       ;;elixir            ; erlang done right
       ;;elm               ; care for a cup of TEA?
       emacs-lisp        ; drown in parentheses
       ;;erlang            ; an elegant language for a more civilized age
       ;;ess               ; emacs speaks statistics
       ;;faust             ; dsp, but you get to keep your soul
       ;;fsharp           ; ML stands for Microsoft's Language
       ;;fstar             ; (dependent) types and (monadic) effects and Z3
       ;;(go +lsp)         ; the hipster dialect
       ;;(haskell +dante)  ; a language that's lazier than I am
       ;;hy                ; readability of scheme w/ speed of python
       ;;idris             ;
       ;;json              ; At least it ain't XML
       ;;(java +meghanada) ; the poster child for carpal tunnel syndrome
       javascript        ; all(hope(abandon(ye(who(enter(here))))))
       ;;julia             ; a better, faster MATLAB
       ;;kotlin            ; a better, slicker Java(Script)
       ;;latex             ; writing papers in Emacs has never been so fun
       ;;lean
       ;;factor
       ;;ledger            ; an accounting system in Emacs
       ;;lua               ; one-based indices? one-based indices
       markdown          ; writing docs for people to ignore
       ;;nim               ; python + lisp at the speed of c
       ;;nix               ; I hereby declare "nix geht mehr!"
       ;;ocaml             ; an objective camel
       org               ; organize your plain life in plain text
       ;;perl              ; write code no one else can comprehend
       ;;php               ; perl's insecure younger brother
       ;;plantuml          ; diagrams for confusing people more
       ;;purescript        ; javascript, but functional
       python            ; beautiful is better than ugly
       ;;qt                ; the 'cutest' gui framework ever
       ;;racket            ; a DSL for DSLs
       ;;rest              ; Emacs as a REST client
       ;;rst               ; ReST in peace
       (ruby +rails +rvm +lsp)       ; 1.step {|i| p "Ruby is #{i.even? ? 'love' : 'life'}"}
       ;;rust              ; Fe2O3.unwrap().unwrap().unwrap().unwrap()
       ;;scala             ; java, but good
       ;;scheme            ; a fully conniving family of lisps
       sh                ; she sells {ba,z,fi}sh shells on the C xor
       ;;sml
       ;;solidity          ; do you need a blockchain? No.
       ;;swift             ; who asked for emoji variables?
       ;;terra             ; Earth and Moon in alignment for performance.
       web               ; the tubes
       yaml              ; JSON, but readable

       :config
       ;;literate
       (default +smartparens))

packages.el

;; -*- no-byte-compile: t; -*-
;;; $DOOMDIR/packages.el

;; To install a package with Doom you must declare them here, run 'doom sync' on
;; the command line, then restart Emacs for the changes to take effect.
;; Alternatively, use M-x doom/reload.

;; Needed for MacOS because it's weird.
(package! exec-path-from-shell)
(package! evil-replace-with-register)
(package! feature-mode)