Giter VIP home page Giter VIP logo

nano-emacs's Introduction

GNU Emacs / N Λ N O

GNU Emacs / N Λ N O is a set of configuration files for GNU Emacs such as to provide a nice and consistent look and feel as shown below. It is based on design principles I described in the article "On the design of text Editors" that is available on arXiv. The light theme is based on Material colors and the dark theme is based on Nord colors.

The philosophy of nano emacs is to stick as much as possible to vanilla emacs without introducing too much dependencies (or none if possible) and to keep it modular enough. The idea is for users to copy the part they are interested in such as to include them in their own configuration.

Nano Emacs is quite close to my other project Elegant Emacs which might be considered to be an early prototype.

Requirements

You need a recent version of GNU Emacs and to have the Roboto Mono and Fira Code fonts installed on your system. There are no other dependencies.

Quick test

The easiest way to test nano emacs is to clone the directory on your desktop and to type (from inside the cloned repository):

$ emacs -q -l nano.el

Installation

If you like the result, you can either manually merge the contents of nano.el into your emacs configuration file, or install nano through the straight.el package manager.

Manual Installation

To merge the nano.el contents with your emacs configuration, you'll need to modify the load-path to include the nano emacs repository and then call for the different modules. The only mandatory module is nano-faces that defines 6 faces that are used in other modules.

Installation through straight.el

To install nano through straight.el, install straight.el, and then add the following snippet into your emacs configuration:

(straight-use-package
  '(nano :type git :host github :repo "rougier/nano-emacs"))

from here, you may either (require 'nano) to pull in the default nano configuration, or call for the different modules. The only mandatory module is nano-faces that defines 6 faces that are used in other modules.

Customization

You can customize the default font, the proportional font and the font-size.

(setq nano-font-family-monospaced "Roboto Mono")

This sets the default monospaced font. Defaults to Roboto Mono. Note that if you set this to a font without proper light or bold weights you will lose many of the key design features of nano-emacs.

(setq nano-font-family-proportional nil)

Set this to the name (as a string) of your favorite variable-width font to enable variable-width-mode and mixed-pitch-mode. If you have already set this somewhere else, you can use (setq nano-font-family-proportional (face-attribute 'variable-width :family)) to use the same one.

(setq nano-font-size 14)

This sets the font-size of most faces in nano-emacs.

Note about load-order

Because of the way nano-emacs is set up, you need to set these variables before you call (nano-faces) and (nano-theme). If you change one of these variables after load/calling (nano-faces) and (nano-theme), you will need to call them again for these changes to take effect.

Modules

  • nano.el (optional)

    This module is mostly used to test nano emacs locally. Its content is supposed to be merged into an existing emacs configuration. See Quick test section above.

Mandatory

  • nano-base-colors.el

    This module defines the fundamental colors of nano theme. If your Emacs has a theme or color-scheme, make sure its loaded before you load nano-faces so that its colors are used by nano.

  • nano-faces.el

    This module defines the fundamental faces of nano theme. If your Emacs has a theme or color-scheme, make sure its loaded before you load nano-faces so that its colors are used by nano.

Optional

  • nano-theme-light.el & nano-theme-dark.el

    Theses modules define light and dark themes respectively by overriding the base colors. If your Emacs is not themed, you are encouraged to try one of these.

  • nano-theme.el

    This module derives faces for several popular emacs modes from the nano faces. You can either use them all by calling (nano-theme), or pick what you want by calling your selection of (nano-theme-- functions.

  • nano-help.el

    This module provides a function to display a small help message in the echo area.

  • nano-splash.el

    This module provides a splash screen when emacs is started.

  • nano-modeline.el

    This module defines a header line that is mode dependent and takes care of hiding the modeline when necessary.

  • nano-layout.el

    This module defines the overall layout of an emacs frame, defining default font, fringes, margins, etc.

  • nano-defaults.el

    This modules provides a set of sane default settings for Emacs.

  • nano-session.el

    This modules configures Emacs such that a session is saved from one run to the other.

  • nano-bindings.el

    This modules provides a reduced set of keybindings for a few common commands.

  • nano-counsel.el

    This modules configures the counsel package that needs to have been installed by user.

  • nano-colors.el

    This module provides a collection of colors palettes (open colors, material colors, nord colors) with functions for easily accessing them.

Experimental

  • nano-mu4e.el

    This package setup the look and feel of mu4e.

  • nano-minibuffer.el

    Minibuffer using mini-frame

  • nano-command.el

    This package provides an experimental command line prompt in the header line. It has not history nor completion but can be used for one line input such as org-capture.

  • nano-agenda.el

    An experimental interactive mini agenda that displays side by side a mini calendar on the left and timestamped org entries on the right.

Related works

  • Bespoke theme Custom medium contrast light and dark themes inspired by nano emacs, elegant emacs, Nord and Solarized themes.

nano-emacs's People

Contributors

akirak avatar alissa-tung avatar apc avatar azzamsa avatar balakrishnanc avatar cmacrae avatar d12frosted avatar d4ncer avatar dangom avatar dieggsy avatar divinedominion avatar duianto avatar elken avatar frederic-santos avatar jacksonbenete avatar lgatto avatar lynlevenick avatar mrzor avatar ndw avatar novoid avatar peterewills avatar qur2 avatar rougier avatar sam217pa avatar shankar2k avatar shassard avatar tefkah avatar utrack avatar wakatara avatar willpower3309 avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

nano-emacs's Issues

Question about contributing

Hey @rougier 👋

I've been working on adding support for a few packages that I use across a few branches of my fork which I'm intended to raise PRs for.
Some not finished and certainly more to come, but I wanted to ask what your preference would be around the approach for some of these.

For instance, in my branch to support Neotree, I've implemented conditional all-the-icons and projectile support so it looks like this:
image

It will fallback to no icon and the directory name instead of project, but; would you generally prefer to keep this sort of logic out of the main theme?

Font lock issue with `web-mode`

First off, thank you for releasing this! It's a gorgeous foundation and I'm enjoying molding my config around it.

I'm having issues with font-lock in web-mode and web-mode derived buffers:

Backtrace

Debugger entered--Lisp error: (wrong-number-of-arguments #<subr quote> 0)
  quote()
  funcall(quote)
  (if (fboundp keywords) (funcall keywords) (eval keywords))
  (font-lock-eval-keywords (if (fboundp keywords) (funcall keywords) (eval keywords)))
  (if (listp keywords) keywords (font-lock-eval-keywords (if (fboundp keywords) (funcall keywords) (eval keywords))))
  font-lock-eval-keywords(quote)
  (set (make-local-variable 'font-lock-keywords) (font-lock-eval-keywords keywords))
  (let* ((defaults font-lock-defaults) (keywords (font-lock-choose-keywords (nth 0 defaults) (font-lock-value-in-major-mode font-lock-maximum-decoration))) (local (cdr (assq major-mode font-lock-keywords-alist))) (removed-keywords (cdr-safe (assq major-mode font-lock-removed-keywords-alist)))) (set (make-local-variable 'font-lock-keywords-only) (nth 1 defaults)) (set (make-local-variable 'font-lock-keywords-case-fold-search) (nth 2 defaults)) (if (null (nth 3 defaults)) (set (make-local-variable 'font-lock-syntax-table) nil) (set (make-local-variable 'font-lock-syntax-table) (copy-syntax-table (syntax-table))) (let ((--dolist-tail-- (nth 3 defaults))) (while --dolist-tail-- (let ((selem (car --dolist-tail--))) (let ((syntax ...)) (let (...) (while --dolist-tail-- ...))) (setq --dolist-tail-- (cdr --dolist-tail--)))))) (let ((--dolist-tail-- (nthcdr (if (consp (nth 4 defaults)) 4 5) defaults))) (while --dolist-tail-- (let ((x (car --dolist-tail--))) (set (make-local-variable (car x)) (cdr x)) (setq --dolist-tail-- (cdr --dolist-tail--))))) (print-elements-of-list font-lock-keywords) (set (make-local-variable 'font-lock-keywords) (font-lock-eval-keywords keywords)) (while local (font-lock-add-keywords nil (car (car local)) (cdr (car local))) (setq local (cdr local))) (if removed-keywords (progn (font-lock-remove-keywords nil removed-keywords))) (if (eq (car font-lock-keywords) t) nil (setq font-lock-keywords (font-lock-compile-keywords font-lock-keywords))))
  (if (and font-lock-set-defaults (eq font-lock-major-mode major-mode)) nil (setq font-lock-major-mode major-mode) (setq font-lock-set-defaults t) (let* ((defaults font-lock-defaults) (keywords (font-lock-choose-keywords (nth 0 defaults) (font-lock-value-in-major-mode font-lock-maximum-decoration))) (local (cdr (assq major-mode font-lock-keywords-alist))) (removed-keywords (cdr-safe (assq major-mode font-lock-removed-keywords-alist)))) (set (make-local-variable 'font-lock-keywords-only) (nth 1 defaults)) (set (make-local-variable 'font-lock-keywords-case-fold-search) (nth 2 defaults)) (if (null (nth 3 defaults)) (set (make-local-variable 'font-lock-syntax-table) nil) (set (make-local-variable 'font-lock-syntax-table) (copy-syntax-table (syntax-table))) (let ((--dolist-tail-- (nth 3 defaults))) (while --dolist-tail-- (let ((selem ...)) (let (...) (let ... ...)) (setq --dolist-tail-- (cdr --dolist-tail--)))))) (let ((--dolist-tail-- (nthcdr (if (consp ...) 4 5) defaults))) (while --dolist-tail-- (let ((x (car --dolist-tail--))) (set (make-local-variable (car x)) (cdr x)) (setq --dolist-tail-- (cdr --dolist-tail--))))) (print-elements-of-list font-lock-keywords) (set (make-local-variable 'font-lock-keywords) (font-lock-eval-keywords keywords)) (while local (font-lock-add-keywords nil (car (car local)) (cdr (car local))) (setq local (cdr local))) (if removed-keywords (progn (font-lock-remove-keywords nil removed-keywords))) (if (eq (car font-lock-keywords) t) nil (setq font-lock-keywords (font-lock-compile-keywords font-lock-keywords)))) (font-lock-flush))
  font-lock-set-defaults()
  (cond (mode (let ((spec (cons keywords how)) cell) (if (setq cell (assq mode font-lock-keywords-alist)) (if (eq how 'set) (setcdr cell (list spec)) (setcdr cell (append (cdr cell) (list spec)))) (setq font-lock-keywords-alist (cons (list mode spec) font-lock-keywords-alist)))) (font-lock-update-removed-keyword-alist mode keywords how)) (t (if (and font-lock-mode (not (or font-lock-keywords font-lock-defaults))) (progn (font-lock-mode -1) (set (make-local-variable 'font-lock-defaults) '(nil t)) (font-lock-mode 1))) (font-lock-set-defaults) (let ((was-compiled (eq (car font-lock-keywords) t))) (if was-compiled (setq font-lock-keywords (car (cdr font-lock-keywords)))) (if (eq how 'set) (setq font-lock-keywords keywords) (font-lock-remove-keywords nil keywords) (let ((old (if ... ... font-lock-keywords))) (setq font-lock-keywords (if how (append old keywords) (append keywords old))))) (if was-compiled (setq font-lock-keywords (font-lock-compile-keywords font-lock-keywords))))))
  font-lock-add-keywords(nil (((lambda (bound) (hl-todo--search nil bound)) (1 (hl-todo--get-face) prepend t))) t)
  hl-todo--setup()
  hl-todo-mode()
  run-hooks(change-major-mode-after-body-hook prog-mode-hook web-mode-hook)
  apply(run-hooks (change-major-mode-after-body-hook prog-mode-hook web-mode-hook))
  run-mode-hooks(web-mode-hook)
  web-mode()

Key Variables

  • font-lock-defaults : ('(web-mode-fontify) t)
  • font-lock-keywords : (t (([(),;{}] 0 ’parenthesis)) ([(),;{}] (0 ’parenthesis)))

What I've tried so far

  • I originally encountered this problem in a web-mode derived buffer for TSX, but I've been able to replicate it in a plain web-mode buffer, so I believe that's the issue.
  • Disabled all other modes to isolate the issue to web-mode

Any help debugging further would be welcome!

Font ‘Roboto Mono Emacs Regular 14’ is not defined"

Thanks for your work to enhance the look and feel of emacs.
I have a warning at startup "frame-notice-user-settings: Font ‘Roboto Mono Emacs Regular 14’ is not defined". I have the Roboto Mono font fully installed from the link provided in the README. Do I need to install other "Roboto" fonts ?

Doesn't work with keycast: Wrong type argument: listp, "%-"

Hi,

Using keycast like this:

(use-package keycast
  :config
  :ensure t)

When enabling keycast using M-x keycast I get:

keycast-mode: Wrong type argument: listp, "%-"

In nano I randomly tried this:

modified   nano-modeline.el
@@ -496,7 +496,7 @@
 	      (eq (window-in-direction 'below) (minibuffer-window))
 	      (not (window-in-direction 'below)))
 	      (with-current-buffer (window-buffer window)
-	        (setq mode-line-format "%-"))
+	        (setq mode-line-format '("%-")))
 	    (with-current-buffer (window-buffer window)
  	      (setq mode-line-format nil)))
 ;;      (if (window-in-direction 'above)
@@ -506,7 +506,7 @@
 (add-hook 'window-configuration-change-hook 'nano-modeline-update-windows)
 
 (setq eshell-status-in-modeline nil)
-(setq-default mode-line-format "%-")
+(setq-default mode-line-format '("%-"))
 (nano-modeline)
 
 (provide 'nano-modeline)

But then I got:

funcall-interactively: Wrong type argument: consp, nil
user-error: Cannot turn on keycast-mode.  mode-line-buffer-identification not found in mode-line-format.  Try customizing keycast-insert-after.

The keycast function is defined there https://github.com/tarsius/keycast/blob/master/keycast.el#L41-L52 but I'm not fluent enough in elisp to fix this.

Error when running `emacs -q -l nano.el` in Termux.

Symbol’s function definition is void: tool-bar-mode

Is this caused by any GUI options?
I tried to install Emacs with X, but it seems no longer seen as x11-repo/emacs.

window-system is a variable defined in ‘C source code’.
Its value is nil
It is a terminal-local variable; global value is the same.

  Probably introduced at or before Emacs version 21.1.

Documentation:
Name of window system through which the selected frame is displayed.

Invalid face, message-cited-text-1

I like very much the look and feel of emacs nano. But I get the following error when loading with require. It may be something I am doing wrong when loading the nano-dark-theme module?
Thanks for any help, and emacs-nano looks awesome, congrats!

Debugger entered--Lisp error: (error "Invalid face" message-cited-text-1)

internal-set-lisp-face-attribute(message-cited-text-1 :family unspecified 0)

set-face-attribute(message-cited-text-1 nil :foreground unspecified :background unspecified :family unspecified :slant unspecified :weight unspecified :height unspecified :underline unspecified :overline unspecified :box unspecified :inherit nano-face-faded)

set-face(message-cited-text-1 nano-face-faded)
(lambda nil (set-face (quote message-cited-text) (quote nano-face-faded)) (set-face (quote message-cited-text-1) (quote nano-face-faded)) (set-face (quote message-cited-text-2) (quote nano-face-faded)) (set-face (quote message-cited-text-3) (quote nano-face-faded)) (set-face (quote message-cited-text-4) (quote nano-face-faded)) (set-face (quote message-header-cc) (quote nano-face-default)) (set-face (quote message-header-name) (quote nano-face-strong)) (set-face (quote message-header-newsgroups) (quote nano-face-default)) (set-face (quote message-header-other) (quote nano-face-default)) (set-face (quote message-header-subject) (quote nano-face-salient)) (set-face (quote message-header-to) (quote nano-face-salient)) (set-face (quote message-header-xheader) (quote nano-face-default)) (set-face (quote message-mml) (quote nano-face-popout)) (set-face (quote message-separator) (quote nano-face-faded)))()

eval-after-load(message (lambda nil (set-face (quote message-cited-text) (quote nano-face-faded)) (set-face (quote message-cited-text-1) (quote nano-face-faded)) (set-face (quote message-cited-text-2) (quote nano-face-faded)) (set-face (quote message-cited-text-3) (quote nano-face-faded)) (set-face (quote message-cited-text-4) (quote nano-face-faded)) (set-face (quote message-header-cc) (quote nano-face-default)) (set-face (quote message-header-name) (quote nano-face-strong)) (set-face (quote message-header-newsgroups) (quote nano-face-default)) (set-face (quote message-header-other) (quote nano-face-default)) (set-face (quote message-header-subject) (quote nano-face-salient)) (set-face (quote message-header-to) (quote nano-face-salient)) (set-face (quote message-header-xheader) (quote nano-face-default)) (set-face (quote message-mml) (quote nano-face-popout)) (set-face (quote message-separator) (quote nano-face-faded))))

eval-buffer(#<buffer *load*-711198> nil "c:/Users/mkess/.emacs.d/lisp/nano-emacs/nano-theme.el" nil t) ; Reading at buffer position 14093
load-with-code-conversion("c:/Users/mkess/.emacs.d/lisp/nano-emacs/nano-theme.el" "c:/Users/mkess/.emacs.d/lisp/nano-emacs/nano-theme.el" nil t)
require(nano-theme)
eval-buffer(#<buffer *load*-892567> nil "c:/Users/mkess/.emacs.d/lisp/nano-emacs/nano-theme-dark.el" nil t) ; Reading at buffer position 1311
load-with-code-conversion("c:/Users/mkess/.emacs.d/lisp/nano-emacs/nano-theme-dark.el" "c:/Users/mkess/.emacs.d/lisp/nano-emacs/nano-theme-dark.el" nil t)
require(nano-theme-dark)
eval-buffer(#<buffer *load*> nil "c:/Users/mkess/.emacs.d/init.el" nil t) ; Reading at buffer position 3190
load-with-code-conversion("c:/Users/mkess/.emacs.d/init.el" "c:/Users/mkess/.emacs.d/init.el" t t) load("c:/Users/mkess/.emacs.d/init" t t)d

Comment about italics

I noticed that the italics style and color is defined by nano-face-faded. But in your article you said that faded "is for secondary information that is less important". Which I think is the opposite case of italics, we should use it to emphasize important stuff. I noticed that in org where the italics were barely visible in the theme I was trying (nord-theme from melpa).

Should `org-return-follows-link` be set to `t`?

Thanks for your work on this terrific project.

I suspect you have already considered this and rejected it, but in case you haven't: wouldn't it make sense to set org-return-follows-link to t? That way, especially when visiting the quick-help, newcomers will be more likely to realize you can make use of the links without using the mouse. (Not everyone will try C-c C-o with point on 'Full preferences', for example, but probably everyone familiar with using the keyboard to follow hyperlinks will try RET...)

Slows down scrolling and loads the processor by 100%

I really liked the design of nano emacs, but after installation I noticed that when scrolling, strong brakes are noticeable, although the settings are set to a smooth scrolling mode. This problem was not observed on standard emacs settings. Tell me this for everyone, or can you tweak some settings?

Proposal: make faces actually customizable

Presently, the faces that nano defines are not customizable in custom, because they are procedurally derived after being defined.

I believe it's possible to make the faces customizable by moving the derivations inside the face setter or default fns. The goal is to allow users to override any nano faces to their liking using customize. A side benefit would be a nicer code layout, because derivation code for each face would be closer to the relevant defface.

Default color for level 1 org-mode headers

Both the light and the dark mode have a default color for level 1 org-mode headers that make the contents of the header (ie paragraphs under the header) to light to read. I don't see an easy way to modify the color so for now nano-el is unusable for me. If I could have guidance to easily change this color that would be nice.

Having nano-emacs around breaks building other modules

There are 2 problems in nano-emacs code base that breaks my borg-based setup:

  1. nano-defaults.el has top-level instructions with side effect: e.g., (setq-default shell-file-name "/bin/zsh"). This means that loading the file changes Emacs. I suggest wrapping these changes in a nano-defaults function.
  2. nano-defaults.el mixes general-purpose improvements and user-specific configuration (e.g., your email address, name and favorite shell). I suggest moving your configuration to a dedicated file outside of this repository.

My actual problem is that batch compiling my Emacs packages loads nano-defaults.el which changes the default shell to /bin/zsh (which I don't have) and this breaks compiling a subsequent Emacs package.

[Question] Automatic preview of text formatting org-mode

So, I'm just started my journey in Emacs, and I've been loving nano! Recently I realized that somehow the org-mode text formatting like =verbatin= was shown as
image

How do I disable this behavior? I do have some programming experience but my elisp skills are almost none.

Segmentation Fault when using nano-layout

Weirdly, when requiring nano-layout in my own config, I get a segmentation fault and emacs crashes on startup.
Using the example config with -q works, though. Also, all other modules don't seem to cause any issues. Any idea what this could be about?

Bold inside org-mode

Hello, how are you?

Even using the quick test it seems that my face configuration for bold is the same as the default text, at least for org-mode. In org-mode the headings are not becoming any different and the *bold* doesn't also doesn't change the looks of regular text.
Is this a problem with my setup or a proper issue?

Nano and helm?

I'm trying a little harder to build a configuration on top of nano. Mostly because I want to try out the mu4e customization, but also because I expect almost thirty years of emacs hacking has, uh, bloated things a little. I wondered what it would be like to try nano and add just the things I need.

One of the things I've gotten used to is helm. But if I load helm and nano, I get invalid face messages.

Here's my pared down config:

;; Can't use straight to load nano-emacs because it compiles
;; nano-layout.elc and https://github.com/rougier/nano-emacs/issues/28

(add-to-list 'load-path "~/.emacs.d/personal/nano-emacs")
(require 'nano-faces)
(require 'nano-layout)
(require 'nano-theme)
(require 'nano-theme-dark)
(require 'nano-theme-light)
(require 'nano-splash)
(require 'nano-modeline)

;;; Define Nano dark & light theme functions

(defun nano-theme-dark ()
  "Enable dark Nano theme and customizations."
  (interactive)
  (nano-theme-set-dark)
  (nano-faces)
  (nano-theme)
  ;; Fall back font for glyph missing in Roboto
  (defface fallback '((t :family "Fira Code"
                         :inherit 'nano-face-faded)) "Fallback")
  (set-display-table-slot standard-display-table 'truncation
                          (make-glyph-code ?… 'fallback))
  (set-display-table-slot standard-display-table 'wrap
                          (make-glyph-code ?↩ 'fallback)))

(defun nano-theme-light ()
  "Enable light Nano theme and customizations."
  (interactive)
  (nano-theme-set-light)
  (nano-faces)
  (nano-theme)
  ;; Fall back font for glyph missing in Roboto
  (defface fallback '((t :family "Fira Code"
                         :inherit 'nano-face-faded)) "Fallback")
  (set-display-table-slot standard-display-table 'truncation
                          (make-glyph-code ?… 'fallback))
  (set-display-table-slot standard-display-table 'wrap
                          (make-glyph-code ?↩ 'fallback)))

;;; Set Theme
(nano-theme-light)

;;; Provide theme for init.el
(provide 'setup-theme)

;; ============================================================

;; Remove the built-in version of Org from the load-path
;; We'll load a more modern version below...
(require 'cl-seq)
(setq load-path
      (cl-remove-if
       (lambda (x)
         (string-match-p "org$" x))
       load-path))

;; Bootstrap straight.el
(defvar bootstrap-version)
(let ((bootstrap-file
       (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
      (bootstrap-version 5))
  (unless (file-exists-p bootstrap-file)
    (with-current-buffer
        (url-retrieve-synchronously
         "https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el"
         'silent 'inhibit-cookies)
      (goto-char (point-max))
      (eval-print-last-sexp)))
  (load bootstrap-file nil 'nomessage))

;; Load the straight.el version of use-package
(defvar straight-use-package-by-default)
(straight-use-package 'use-package)

;; Tell straight to use use-package by default
(setq straight-use-package-by-default t)

;; Tell straight to use ssh by default, instead of https.
(setq straight-vc-git-default-protocol 'ssh)

;; ============================================================
;;
;;(setq ndw/org-local-build "/Users/ndw/Projects/emacs/org-mode/lisp")
;;(setq ndw/org-local-build nil)
;;(if (and ndw/org-local-build (file-directory-p ndw/org-local-build))
;;    (add-to-list 'load-path ndw/org-local-build)
;;  (use-package org-plus-contrib
;;    :mode (("\\.org$" . org-mode))))
;;
;; ============================================================

(use-package helm
  :init
  (setq helm-split-window-inside-p            t
        helm-move-to-line-cycle-in-source     t
        helm-ff-search-library-in-sexp        t
        helm-scroll-amount                    8
        helm-ff-file-name-history-use-recentf t)
  ;; Remove helm-source-info-cl which I don't seem to have
  (setq helm-info-default-sources
        '(helm-source-info-elisp
          helm-source-info-eieio
          helm-source-info-pages))
  :bind (("<f1>" .      helm-resume)
;         ("<f2>" .      helm-execute-kmacro)
         ("C-," .       helm-calcul-expression)
         ("C-:" .       helm-eval-expression-with-eldoc)
         ("C-c <SPC>" . helm-all-mark-rings)
         ("C-c f" .     helm-recentf)
         ("C-c g" .     helm-gid)
         ("C-c i" .     helm-imenu)
         ("C-c I" .     helm-imenu-in-all-buffers)
         ("C-h C-s" .   helm-occur)
         ("C-h a" .     helm-apropos)
         ("C-h f" .     helm-find)
         ("C-h g" .     helm-google-suggest)
         ("C-h i" .     helm-info-at-point)
         ("C-h r" .     helm-info-emacs)
;         ("C-h s" .     helm-swoop)
         ("C-x C-d" .   helm-browse-project)
         ("C-x C-f" .   helm-find-files)
         ("C-x b" .     helm-mini)
;         ("C-x r b" .   helm-filtered-bookmarks)
;         ("C-x c b" .   helm-chrome-bookmarks)
         ("M-x" .       helm-M-x)
         ("M-y" .       helm-show-kill-ring)
         ("M-g a" .     helm-do-grep-ag)
         ([remap jump-to-register] . helm-register)
         ([remap list-buffers]     . helm-buffers-list)
         ([remap dabbrev-expand]   . helm-dabbrev)
         ([remap find-tag]         . helm-etags-select)
         ([remap xref-find-definitions] . helm-etags-select))
)

;; ============================================================

With (just) this in my init.el, I get an invalid face (helm-swoop-target-line-face) as soon as I do anything that tries to prompt in the minibuffer.

With this configuration I can't even get a stack trace to occur, but I did with a slightly less minimal configuration and it was falling over in the with-eval-after-load 'helm code in nano-theme.el, I believe.

Additional requirements: ivy / counsel

The readme requirements, state that only Emacs and fonts are required:
https://github.com/rougier/nano-emacs#requirements

You need a recent version of GNU Emacs and to have the Roboto Mono and Fira Code fonts installed on your system. There are no other dependencies.

After downloading the repository ZIP.
Extracting it and running:

runemacs -q -l nano.el

It first complained about the font:

frame-notice-user-settings: Font ‘Roboto Mono:style=Light:size=14’ is not defined

(understandable since the font wasn't installed)

After installing the Roboto Mono font:
https://fonts.google.com/specimen/Roboto+Mono
and restarting Emacs with nano.el.

Issue:

Now it says:

eval-buffer: Symbol’s function definition is void: ivy-mode

Source:

(ivy-mode 1)

And pressing: M-x
shows:

command-execute: Wrong type argument: commandp, counsel-M-x

(global-set-key (kbd "M-x") 'counsel-M-x)

A possible solution

Maybe the nano-counsel requirement should be commented out by default.

nano-emacs/nano.el

Lines 69 to 71 in 7097101

;; Nano counsel configuration (optional)
;; Needs "counsel" package to be installed (M-x: package-install)
(require 'nano-counsel)

Since it disables M-x.

System:

  • GNU Emacs 27.1 (build 1, x86_64-w64-mingw32) of 2020-08-21
  • Windows 10 2004

Modeline gets lost when using emacs ipython notebook

Thanks for all the work on this, it's really beautiful. I'm working on getting it to play nice with all my tools.

I've noticed that in emacs ipython notebook, since that library also controls the top line of the buffer and uses it to display status (information about the notebook kernel), the modeline disappears. It would be great if it would appear at the top of the buffer, and the EIN status would appear one line below.

Screen Shot 2020-12-30 at 9 36 31 PM

Proposal: Allow dark/light theme switching

Unless I'm missing something, right now you have to specify either the -dark or -light command flag at startup to choose a theme. It would be more convenient (and more emacsy) to instead provide themes that can be activated using the load-theme command. What road blocks are there to adding this feature? I'd like to help.

Problems with minibuffer when modeline is disbled

Hey!
I'm actually not that new to emacs, but I used to use doom emacs, but now I'm trying to configure vanilla emacs. I thought starting out with nano-emacs would be great because it matches my taste, and till now, I'm LOVING nano-emacs.

I have one problem though:
I saw that you are disabling menu-bar-mode conditionally (I don't know much elisp, so forgive me if I use programming terms unrelated to elisp but to other languages). But that does not disable the menu bar for me, even though I'm not using OSX (you mentioned it in the comment). If I remove

;; No menu bar
(if (display-graphic-p)
    (menu-bar-mode t) ;; When nil, focus problem on OSX
  (menu-bar-mode -1))

and replace it with just
(menu-bar-mode -1) , the minibuffer doesn't show up when I start emacs, or sometimes it shows up lower than expected, with half the line cut off, and the line above the text not visible.
2021-02-17-@10-26-29-scrot

It only shows up after some message is displayed in the minibuffer, for example, when type :w <RET> (I use evil mode) on a scratch buffer and the modeline says Please specify a file name for the buffer.
2021-02-17-@10-41-10-scrot

Any help is appreciated,
Thanks.

nano-minibuffer implicitly depends on nano-color

The optional nano-minibuffer.el uses material-color on L54 but does not explicitly load nano-colors.el which is another optional module and therefore causes a backtrace error if your init file doesn't already require nano-colors.

For ease of use by new emacs users, I think it would be better if:

  1. A sentence is added to the description of nano-minibuffer.el in the README that nano-colors.el is also required and must be loaded first, or
  2. nano-colors.el is explicitly loaded by nano-minibuffer.el, or
  3. We replace the call to material-color with one from nano-basecolors.el.

I'll happily make an MR if you have an opinion about which of these options you'd like to see merged.

Layout.el: Wrong Type Argument

In prep for my PR to add install instructions for nano through straight.el, the entire nano project can't be installed as layout.el brings up this error:

Wrong type argument: char-table-p, nil

One solution is to omit it and manually install all the other parts of nano through straight, and essentially recreate nano.el without straight.el (as I showed in my snippet from #43 ), but this takes away from the simplicity of the install

Can't change the font

As requested on Reddit, I'm opening a bug report because I can't change the face used by nano-emacs to Fira Mono

I've cloned the repo to $HOME/.emacs.d, created a nano folder inside .emacs.d and moved all the nano-*.el files to it, except for nano.el that was kept in the root emacs config dir. After that, I renamed nano.el to init.el, changed the load files path to the correct dir and commented the last line:

;; ---------------------------------------------------------------------
;; GNU Emacs / N Λ N O - Emacs made simple
;; Copyright (C) 2020 - N Λ N O developers
;;
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;; ---------------------------------------------------------------------
(package-initialize)

;; Path to nano emacs modules (mandatory)
(add-to-list 'load-path "/home/brunomiguel/.emacs.d/nano")
;; (add-to-list 'load-path ".")

;; Window layout (optional)
(require 'nano-layout)

;; Theming Command line options (this will cancel warning messages)
(add-to-list 'command-switch-alist '("-dark"   . (lambda (args))))
(add-to-list 'command-switch-alist '("-light"  . (lambda (args))))
(add-to-list 'command-switch-alist '("-default"  . (lambda (args))))

(cond
 ((member "-default" command-line-args) t)
 ((member "-dark" command-line-args) (require 'nano-theme-dark))
 (t (require 'nano-theme-light)))

;; Customize support for 'emacs -q' (Optional)
;; You can enable customizations by creating the nano-custom.el file
;; with e.g. `touch nano-custom.el` in the folder containing this file.
(let* ((this-file  (or load-file-name (buffer-file-name)))
       (this-dir  (file-name-directory this-file))
       (custom-path  (concat this-dir "nano-custom.el")))
  (when (and (eq nil user-init-file)
             (eq nil custom-file)
             (file-exists-p custom-path))
    (setq user-init-file this-file)
    (setq custom-file custom-path)
    (load custom-file)))

;; Theme
(require 'nano-faces)
(nano-faces)

(require 'nano-theme)
(nano-theme)

;; Nano default settings (optional)
(require 'nano-defaults)

;; Nano session saving (optional)
(require 'nano-session)

;; Nano header & mode lines (optional)
(require 'nano-modeline)

;; Nano key bindings modification (optional)
(require 'nano-bindings)

;; Nano counsel configuration (optional)
;; Needs "counsel" package to be installed (M-x: package-install)
;; (require 'nano-counsel)

;; Welcome message (optional)
(let ((inhibit-message t))
  (message "Welcome to GNU Emacs / N Λ N O edition")
  (message (format "Initialization time: %s" (emacs-init-time))))

;; Splash (optional)
(add-to-list 'command-switch-alist '("-no-splash" . (lambda (args))))
(unless (member "-no-splash" command-line-args)
  (require 'nano-splash))

;; Help (optional)
(add-to-list 'command-switch-alist '("-no-help" . (lambda (args))))
(unless (member "-no-help" command-line-args)
  (require 'nano-help))

;; (provide 'nano)

In nano-faces.el, I have this:

;;; nano-faces --- Face settings for nano-emacs
;;; License:
;; ---------------------------------------------------------------------
;; GNU Emacs / N Λ N O - Emacs made simple
;; Copyright (C) 2020 - N Λ N O developers
;;
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
;; ---------------------------------------------------------------------
;;; Commentary:
;;
;; This file defines the 6 basic nano faces:
;;
;; - nano-face-critical  - nano-face-popout   - nano-face-salient
;; - nano-face-default   - nano-face-faded    - nano-face-subtle
;;
;; Several nano modules require
;;
;; ---------------------------------------------------------------------
;;; Code:

(require 'nano-base-colors)

;; A theme is fully defined by these six faces

(defface nano-face-default nil
  "Default face is used for normal information."
  :group 'nano)

(defface nano-face-critical nil
  "Critical face is for information that requires immediate action.
It should be of high constrast when compared to other faces. This
can be realized (for example) by setting an intense background
color, typically a shade of red. It must be used scarcely."
  :group 'nano)

(defface nano-face-popout nil
  "Popout face is used for information that needs attention.
To achieve such effect, the hue of the face has to be
sufficiently different from other faces such that it attracts
attention through the popout effect."
  :group 'nano)

(defface nano-face-strong nil
  "Strong face is used for information of a structural nature.
It has to be the same color as the default color and only the
weight differs by one level (e.g., light/normal or
normal/bold). IT is generally used for titles, keywords,
directory, etc."
  :group 'nano)

(defface nano-face-salient nil
  "Salient face is used for information that are important.
To suggest the information is of the same nature but important,
the face uses a different hue with approximately the same
intensity as the default face. This is typically used for links."
  :group 'nano)

(defface nano-face-faded nil
  "Faded face is for information that are less important.
It is made by using the same hue as the default but with a lesser
intensity than the default. It can be used for comments,
secondary information and also replace italic (which is generally
abused anyway)."
  :group 'nano)

(defface nano-face-subtle nil
  "Subtle face is used to suggest a physical area on the screen.
It is important to not disturb too strongly the reading of
information and this can be made by setting a very light
background color that is barely perceptible."
  :group 'nano)

(defface nano-face-header-default nil
  "Default face for ther header line."
  :group 'nano)

(defface nano-face-header-critical nil
  "Critical face for ther header line."
  :group 'nano)

(defface nano-face-header-popout nil
  "Popout face for ther header line."
  :group 'nano)

(defface nano-face-header-strong nil
  "Strong face for ther header line."
  :group 'nano)

(defface nano-face-header-salient nil
  "Salient face for ther header line."
  :group 'nano)

(defface nano-face-header-faded nil
  "Faded face for ther header line."
  :group 'nano)

(defface nano-face-header-subtle nil
  "Subtle face for ther header line."
  :group 'nano)

(defface nano-face-header-highlight nil
  "Highlight face for ther header line."
  :group 'nano)

(defface nano-face-header-separator nil
  "Face for separating item in the header line (internal use)"
  :group 'nano)

(defface nano-face-header-filler nil
  "Face compsenting spaces in the header line (internal use) "
  :group 'nano)

(defface nano-face-tag-default nil
  "Default face for tags"
  :group 'nano)

(defface nano-face-tag-faded nil
  "Faded face for tags"
  :group 'nano)

(defface nano-face-tag-strong nil
  "Strong face for tags"
  :group 'nano)

(defface nano-face-tag-salient nil
  "Salient face for tags"
  :group 'nano)

(defface nano-face-tag-popout nil
  "Popout face for tags"
  :group 'nano)

(defface nano-face-tag-critical nil
  "Critical face for tags"
  :group 'nano)

(defun nano-what-faces (pos)
  "Get the font faces at POS."
  (interactive "d")
  (let ((faces (remq nil
                     (list
                      (get-char-property pos 'read-face-name)
                      (get-char-property pos 'face)
                      (plist-get (text-properties-at pos) 'face)))))
    (message "Faces: %s" faces)))

(defun nano-faces ()
  "Derive face attributes for nano-faces using nano-theme values."
  (set-face-attribute 'nano-face-default nil
                      :foreground nano-color-foreground
                      :background nano-color-background)
  (set-face-attribute 'nano-face-critical nil
                      :foreground nano-color-foreground
                      :background nano-color-critical)
  (set-face-attribute 'nano-face-popout nil
                      :foreground nano-color-popout)

  (if (display-graphic-p)
      (set-face-attribute 'nano-face-strong nil
                          :foreground (face-foreground 'nano-face-default)
                          :family "Fira Mono"
                          :weight 'medium)
    (set-face-attribute 'nano-face-strong nil
                        :foreground (face-foreground 'nano-face-default)
                        :weight 'bold))

  (set-face-attribute 'nano-face-salient nil
                      :foreground nano-color-salient
                      :weight 'light)

  (set-face-attribute 'nano-face-faded nil
                      :foreground nano-color-faded
                      :weight 'light)

  (set-face-attribute 'nano-face-subtle nil
                      :background nano-color-subtle)

  (set-face-attribute 'nano-face-header-default nil
                      :foreground nano-color-foreground
                      :background nano-color-subtle
                      :box `(:line-width 1
                                         :color ,nano-color-background
                                         :style nil))

  (set-face-attribute 'nano-face-tag-default nil
                      :foreground nano-color-foreground
                      :background nano-color-background
                      :family "Fira Mono" :weight 'normal
                      :height (if (display-graphic-p) 120 1)
                      :box `(:line-width 1
                                         :color ,nano-color-foreground
                                         :style nil))

  (set-face-attribute 'nano-face-header-strong nil
                      :foreground nano-color-strong
                      :background nano-color-subtle
                      :inherit 'nano-face-strong
                      :box `(:line-width 1
                                         :color ,nano-color-background
                                         :style nil))

  (set-face-attribute 'nano-face-tag-strong nil
                      :foreground nano-color-strong
                      :background nano-color-subtle
                      :family "Fira Mono" :weight 'normal
                      :height (if (display-graphic-p) 120 1)
                      :box `(:line-width 1
                                         :color ,nano-color-strong
                                         :style nil))

  (set-face-attribute 'nano-face-header-salient nil
                      :foreground nano-color-background
                      :background nano-color-salient
                      :box `(:line-width 1
                                         :color ,nano-color-background
                                         :style nil))

  (set-face-attribute 'nano-face-tag-salient nil
                      :foreground nano-color-background
                      :background nano-color-salient
                      :family "Fira Mono" :weight 'normal
                      :height (if (display-graphic-p) 120 1)
                      :box `(:line-width 1
                                         :color ,nano-color-salient
                                         :style nil))

  (set-face-attribute 'nano-face-header-popout nil
                      :foreground nano-color-background
                      :background nano-color-popout
                      :box `(:line-width 1
                                         :color ,nano-color-background
                                         :style nil))

  (set-face-attribute 'nano-face-tag-popout nil
                      :foreground nano-color-background
                      :background nano-color-popout
                      :family "Fira Mono" :weight 'normal
                      :height (if (display-graphic-p) 120 1)
                      :box `(:line-width 1
                                         :color ,nano-color-popout
                                         :style nil))

  (set-face-attribute 'nano-face-header-faded nil
                      :foreground nano-color-background
                      :background nano-color-faded
                      :box `(:line-width 1
                                         :color ,nano-color-background
                                         :style nil))

  (set-face-attribute 'nano-face-tag-faded nil
                      :foreground nano-color-background
                      :background nano-color-faded
                      :family "Fira Mono" :weight 'normal
                      :height (if (display-graphic-p) 120 1)
                      :box `(:line-width 1
                                         :color ,nano-color-faded
                                         :style nil))

  (set-face-attribute 'nano-face-header-subtle nil)

  (set-face-attribute 'nano-face-header-critical nil
                      :foreground nano-color-background
                      :background nano-color-critical
                      :box `(:line-width 1
                                         :color ,nano-color-background
                                         :style nil))
  (set-face-attribute 'nano-face-tag-critical nil
                      :foreground nano-color-background
                      :background nano-color-critical
                      :family "Fira Mono" :weight 'normal
                      :height (if (display-graphic-p) 120 1)
                      :box `(:line-width 1
                                         :color ,nano-color-critical
                                         :style nil))

  (set-face-attribute 'nano-face-header-separator nil
                      :inherit 'nano-face-default
                      :height 0.1)
  (set-face-attribute 'nano-face-header-filler nil
                      :inherit 'nano-face-header-default
                      :height 0.1)
  (set-face-attribute 'nano-face-header-highlight nil
                      :inherit 'nano-face-header-faded
                      :box nil))

(provide 'nano-faces)
;;; nano-faces.el ends here

Yet, when I start Emacs, it doesn't use Fira Mono (installed in /usr/share/fonts).

Emacs version is 27.1

bold font not working in org & md

In a emacs -Q -l nano.el, the bold font in org-mode or markdown-mode doesn't work, it just seems like a normal font without any bold.

I am using macOS and the Roboto Mono font is installed.

The "bold" is actually "*bold*", which is hided because of org-hide-emphasis-markers:
image

Emacs-lisp mode doesn't show correct major-mode

Hey, really neat project you have here! Provides some great aesthetic inspiration for my own config. I found that (format-mode-line "%m") in emacs-lisp-mode returns an empty string, so in emacs-lisp buffers the mode shows up as ().

[Question] Moving minibuffer to the top?

Hi, thanks for this awesome package, it's really pleasing to use.

After reading "On the design of Text Editors", I'm thinking about a better place to put minibuffer (or command palette in general). In Emacs, many people use helm, ivy or other completion framework, which either enlarge minibuffer or create another buffer to display completion list. This may be distracting sometimes (feels like something gigantic popup to you, especially on ultra wide 34 inches screen). Do you think it's a good idea to move minibuffer to the top just like where other editor put their command palette? This way, it's more like a drop down menu and more intuitive to use IMHO.

Or are there any alternative UI for displaying list of candidates? I'm searching for different idea, what do you think?

Eshell doesn't launch with nano-emacs

There is a problem, at least on my conf, that eshell doesn't works with nano-emacs.
I've traced the problem to the (setq-default mode-line-format "%-") on nano-modeline.el.

Commenting the line will cause eshell to run but will leave you with the vanilla modeline at bottom.
If you ever split the window, it will cause the hook at (add-hook 'window-configuration-change-hook 'nano-modeline-update-windows) to correct the modeline.

I'm working on it but I would like a confirmation if this is also happening with someone else as it can be just a conflict in my init.el calls.

Performance question (byte compile)

I'm using emacs nativecomp branch (emacsGcc) with doom-emacs, and it's really fast. One of doom-emacs features is byte-compile elisp files from packages to have a better performance, is this supported here? If not, WDYT about adding this kind of support?

Proposal: Add a way to configure window placement

I think the overall user experience could improve:

  1. when certain type of windows spawn in fixed position.
  2. the modeline could be disabled for certain window types.

Especially point 1 would be nice as certain type of information, dialogs, etc. could be displayed on a certain area of the frame
or in some cases even spawn a new frame.
There are some packages which add this kind of functionality e.g.: https://github.com/emacsorphanage/popwin
I don't now how doable it is.It seems that most solutions I stumbled upon have some tradeoffs.

On point 2: I may be oppionated about this, but in a lot of cases the modeline does not seem necessary to me, e.g. when opening help commands, spell checking or using org-capture.

example of how to get the split terminals working with each other

I'd like to have something similar to the split setup that was shown in your reddit post.

Is there a way to have one terminal that has just a fixed treemacs directory setup and another as the target of the clicks? And how might one go about setting this up?

Contrast

First of all, let me thank you for what I can only call an work of art!

Second, is it possible to easily adjust the constrast? Some colors are too similar for my eyes...

Suggestions partially cut off when using ispell

Not exactly sure I would call this an "issue", but I've been using parts from nano-emacs, and when I use ispell, the bottom row of suggestions is cut off around half way. It doesn't matter how many rows of suggestions are provided. It's always the last row that is partially cut off. I can still read all of the suggestions, so not a big deal, but I was wondering if there is a setting I could change to have all of the suggestions display.

I don't use all of the modules, so maybe this wouldn't happen if I used some of the others? These are the ones I'm using:

  • nano-base-colors
  • nano-faces
  • nano-modeline

Here is a screen of what I see:

Screen Shot 2020-12-24 at 3 02 33 PM

Install with straight.el

I tried to install with straight.el but I'm not sure how to... Maybe someone has successfully installed it with straight?

What I've tried is:

  (use-package nano-emacs
    :straight (:host github :repo "rougier/nano-emacs")
    :demand t)

Which gives the error:

error: nano-writer.el:0:0: error: scan-error: (Unbalanced parentheses 2898 4298)

I assume I'm just doing something wrong here.... maybe someone can point me in the right direction?

Make pieces more independent?

First, I want to say that I really appreciate your vision and sharing your work with others. I was wondering if it is possible to make some of the pieces more independent of each other. I see that you've already made efforts to split things up, but I see a couple of areas where some pieces could be more independent.

Using the modeline module alone, the dashed line above the echo area still has some leftover colors from the original modeline. Is it possible to make it look clean and minimal in a theme agnostic way?
Screenshot 2021-01-02 at 6 48 04 PM

Similarly, using the layout module alone, the vertical divider shows up as very thick. I really like having the extra padding that is provided by this module and could see using it as a standard part of my config, even if I didn't use any other piece of nano-emacs.
Screenshot 2021-01-03 at 12 27 09 PM

Default font size results in tiny font size on a HiDPI display, on Linux

Title says most of it.

Illustration

On the left side, my fullblown Emacs config.
On the right side, latest nano-emacs ran with \emacs -q -l nano.el -dark.

image

Here, on the right side, latest nano-emacs ran with \emacs -q -l nano.el -dark, after editing nano-layout.el as follows:

(setq default-frame-alist
      (append (list
	       '(font . "Roboto Mono:style=Light")

image

Font diagnostics

In my non-nano configuration, default font height is set to 139 (in 1/10pts, so 13.9pts), through (custom-set-faces). Relevant part looks like:
'(default ((t (:inherit nil :stipple nil :background "#0D0D0D" :foreground "#DCDCCC" :inverse-video nil :box nil :strike-through nil :overline nil :underline nil :slant normal :weight normal :height 139 :width normal :foundry "PfEd" :family "Terminus (TTF)"))))

What you can see on the right side is always \emacs -q -l nano.el -dark (with and without fix applied).

(describe-face 'default) in my fullblown Emacs returns:

           Family: Terminus (TTF)
          Foundry: PfEd
            Width: normal
           Height: 139
           Weight: normal
            Slant: normal
       Foreground: #DCDCCC
DistantForeground: unspecified
       Background: #0D0D0D
        Underline: nil
         Overline: nil
   Strike-through: nil
              Box: nil
          Inverse: nil
          Stipple: nil
             Font: #<font-object -PfEd-Terminus (TTF)-normal-normal-normal-*-37-*-*-*-m-0-iso10646-1>
          Fontset: -PfEd-Terminus (TTF)-normal-normal-normal-*-37-*-*-*-m-0-fontset-auto2
           Extend: nil
          Inherit: nil

(describe-face 'default) in master branch using "Roboto Mono:style=Light:size=14" :

           Family: Roboto Mono
          Foundry: GOOG
            Width: normal
           Height: 53
           Weight: normal
            Slant: normal
       Foreground: #37474F
DistantForeground: unspecified
       Background: #FFFFFF
        Underline: nil
         Overline: nil
   Strike-through: nil
              Box: nil
          Inverse: nil
          Stipple: nil
             Font: #<font-object -GOOG-Roboto Mono-normal-normal-normal-*-14-*-*-*-m-0-iso10646-1>
          Fontset: -GOOG-Roboto Mono-normal-normal-normal-*-14-*-*-*-m-0-fontset-auto1
           Extend: nil
          Inherit: nil

(describe-face 'default) using my patched nano config:

           Family: Roboto Mono
          Foundry: GOOG
            Width: normal
           Height: 120
           Weight: normal
            Slant: normal
       Foreground: black
DistantForeground: unspecified
       Background: white
        Underline: nil
         Overline: nil
   Strike-through: nil
              Box: nil
          Inverse: nil
          Stipple: nil
             Font: #<font-object -GOOG-Roboto Mono-normal-normal-normal-*-32-*-*-*-m-0-iso10646-1>
          Fontset: -GOOG-Roboto Mono-normal-normal-normal-*-32-*-*-*-m-0-fontset-auto1
           Extend: nil
          Inherit: nil

Adding size=14 to the font definitions results into Emacs selecting -GOOG-Roboto Mono-normal-normal-normal-*-14-*-*-*-m-0-fontset-auto1 with Height: 53. Omitting it results into Emacs selecting -GOOG-Roboto Mono-normal-normal-normal-*-32-*-*-*-m-0-iso10646-1 with Height: 120.

Hypotheses

a. This could be some weird fontconfig related issue - the interfering thing here would therefore be my chosen way of installing Roboto Mono. I'll look into it more.

b. Wild guess. Using such font definitions in Emacs 27.1+ could be problematic. I seem to recall they added a full new Harfbuzz glyph rendering engine.

c. There are others ways to set the default font, (set-face-font 'default ... comes to mind. Maybe this way works correctly on all platforms.

mode-line-position on pdf-view-mode

Would be good to show the current page number when reading pdfs.
It's easy to get lost without an indicator.

There is a variable called mode-line-position that on pdf-view-mode will return something like "P 3/33" for the current-page/total-pages.

You can see the actual code on the pdf-tools page, but I think this is all what's needed:

(setq-local mode-line-position
              '(" P" (:eval (number-to-string (pdf-view-current-page)))
                ;; Avoid errors during redisplay.
                "/" (:eval (or (ignore-errors
                                 (number-to-string (pdf-cache-number-of-pages)))
                               "???"))))

I'm trying to solve this problem, still not much progress but might not be something hard to do.
I would not know the best style to present this in the mode-line as I'm not good at design and the project is your's.
But probably might be the case to replace (position (format-mode-line "%l:%c")) with this value, since in a pdf page the line:column will be always as "1:0" as far as I know, so in this case it wouldn't be necessary to show the line:column.

Proposal: Support personal configuration directory

Support a <nano-emacs-srcdir>/personal directory to store user configuration.

This is similar to what bbatsov/prelude does. This allows nano-emacs to be used as a first-class Emacs distribution, rather than an embedable one: i.e. you can checkout rougier/nano-emacs into .emacs.d and start configuring your own stuff in .emacs.d/personal. Whenever one wants to upgrade, git pull.

This would be the natural place for you to store your personal settings as well, which are currently versioned in master 😉
It's also the natural place for users to add their own (require ... or (add-to-list 'auto-mode-alist ... or (use-package ... code.

I plan to actually replace my GNU Nano with such a config, once the work is done. Except that my .emacs.d will not be used. I like the idea of having a very lightweight Emacs based on Nano as my terminal editor (i.e. set as EDITOR) while my full blown Emacs IDE remains as it is (for now!).

It's a fairly straightforward change to nano.el, I'll contribute the change and documentation update if you're ok with the idea.

Proposed refactor in order to make modules loadable independently

Greetings!

Thanks for grouping all this goodness into one package! I've been following your works on Reddit for months now, and only in this incarnation I can reasonably hope to integrate some of your design ideas into my prelude-based config.

My focus last night was on integrating your "modeline" (header line, to be honest), and I managed to do so but I had to make quite a number of edits to nano-theme (to preserve my theme, that I'm very used to for now) and nano-modeline (which got completely mangled by parinfer on pasting, and that I had to debug to make work again).

Here's a sneak peak of what I got:
image
Brilliant. I hated my modeline for years. This is much, much better.

My issue is that I'm not happy to have forked such an early piece of code (that is going to change a lot) - and maintaining that fork is going to be a burden. I would much prefer to have nano-emacs code wholesale somewhere in my load path, and use what I want.

To that effect, I'm ready to contribute changes that would refactor the existing code into:

  • Separate nano deffaces from nano-theme into a dedicated nano-faces
  • Wrap the various (set-face-attributes ... in nano-theme into topical fns, like (setup-core-faces) or (setup-modeline-faces).
  • Reindent the code in nano-modeline so that pasting it with parinfer on doesn't break it completely - the README states that a goal is one should be able to paste the code and go. Unconventional indentation prevents that.

I started moving the pieces around, but I'm opening this issue with the hope of starting a conversation about modularity and code style before submitting it.

Buffer switching buttons have disappeared with recent updates

Not sure what's causing this, but with the latest updates from the last few days, the buffer-switching buttons have disappeared. Here's what I would see with emacs -q -l nano.el using the master as of around 10 days ago:
Screen Shot 2020-12-30 at 2 51 02 PM
And here I what I see with master as of this morning:
Screen Shot 2020-12-30 at 2 50 40 PM
In the latest updates, the divider line at the bottom of the frame also looks different (in my opinion, nicer).

Not sure exactly what would be causing the mode line buttons to disappear though.

wrong-type-argument char-table-p

If I byte compile Nano, I get the following error when loading nano-layout:

Debugger entered--Lisp error: (wrong-type-argument char-table-p nil)
  set-char-table-extra-slot(nil 0 (8230 . 101))
  set-display-table-slot(nil truncation (8230 . 101))
  byte-code("\306\307\310\311\312\313\314\315\316\317\320\321\257\13!\20\322\323\324\325#\210\326\11\327\330\331\323\"#\210\326\11\332\330\333\323\"#\210\334\335\336\"\210\337\211\22\23\337..." [default-frame-alist standard-display-table inhibit-startup-screen inhibit-startup-message inhibit-startup-echo-area-message initial-scratch-message append (font . "Roboto Mono:style=Light:size=14") (min-height . 1) (height . 45) (min-width . 1) (width . 81) (vertical-scroll-bars) (internal-border-width . 24) (left-fringe . 0) (right-fringe . 0) (tool-bar-lines . 0) (menu-bar-lines . 0) custom-declare-face fallback ((t :family "Fira Code" :inherit 'nano-face-faded)) "Fallback" set-display-table-slot truncation make-glyph-code 8230 wrap 8617 add-hook term-mode-hook #f(compiled-function () #<bytecode 0x1fe646e81999>) t nil tool-bar-mode 0 tooltip-mode menu-bar-mode global-hl-line-mode 1 24 right-only window-divider-mode provide nano-layout x-underline-at-descent-line window-divider-default-right-width window-divider-default-places widget-image-enable org-hide-emphasis-markers] 13)
  require(nano-layout)
  eval-buffer(#<buffer  *load*> nil "/Users/ndw/testemacs/.emacs.d/init.el" nil t)  ; Reading at buffer position 92
  load-with-code-conversion("/Users/ndw/testemacs/.emacs.d/init.el" "/Users/ndw/testemacs/.emacs.d/init.el" t t)
  load("/Users/ndw/testemacs/.emacs.d/init" noerror nomessage)
  startup--load-user-init-file(#f(compiled-function () #<bytecode 0x1fe646e7f5a9>) #f(compiled-function () #<bytecode 0x1fe646e7f5c1>) t)
  command-line()
  normal-top-level()

I'm running this in a test home directory (HOME=/Users/ndw/testemacs emacs) with this init file:

(add-to-list 'load-path "/Users/ndw/testemacs/.emacs.d/nano-emacs")

(require 'nano-layout)

The nano-emacs directory is just what I cloned from GitHub, with the files byte compiled. I have no trouble loading nano-layout if I delete the .elc file.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.