Git Product home page Git Product logo

zettlr's Introduction

Zettlr
Zettlr [ˈset·lər]

Your One-Stop Publication Workbench.

DOI License: GNU GPL v3 GitHub tag (latest by date) GitHub All Releases Unit Tests / Lint Build

Homepage | Download | Documentation | Mastodon | Discord | Contributing | Support Us

screenshot

Zettlr brings simplicity back to your texts. Open-minded writing that adapts to your style. Fast information retrieval that finds what matters to you. Versatile exporting that enables you to adapt to whatever publication pipeline your employer or school uses.

Focus on what matters to you.

Publish, not perish.

Learn more on our website.

Features

  • Your Notes are your notes: Zettlr is privacy-first
  • Citations made easy: Tight and ever-growing integration with your favourite reference manager (Zotero, JabRef, and many others)
  • Available in over a dozen languages
  • Draft your publications in a professional environment, with LaTeX and Word template support
  • Simple and beautiful exports with Pandoc, LaTeX, and Textbundle
  • Snippets allow you to automate insertion of boilerplate code
  • Themes, dark modes, and full flexibility with custom CSS
  • Code highlighting for many languages
  • Support for state of the art knowledge management techniques (Zettelkasten)
  • A powerful full text search that helps you find anything, anywhere

… and the best is: Zettlr is Free and Open Source Software (FOSS)!

Installation

To install Zettlr, just download the latest release for your operating system. Currently supported are macOS, Windows, and most Linux distributions (via Debian- and Fedora-packages as well as AppImages).

On our website and here on GitHub, we provide a set of installers for the most common use-cases. We provide both 64-bit installers as well as installers for ARM systems (called "Apple Silicon" in the macOS ecosystem). 32-bit is not supported. We offer the following binaries directly:

  • Windows (x64)
  • macOS (Intel and Apple Silicon)
  • Debian and Fedora (x64 and ARM)
  • AppImage (x64 and ARM)

Thanks to our community, we can also offer you a variety of other installation opportunities:

All other platforms that Electron supports are supported as well, but you will need to build the app yourself for this to work.

Please also consider becoming a patron or making a one-time donation!

Getting Started

After you have installed Zettlr, head over to our documentation to get to know Zettlr. Refer to the Quick Start Guide, if you prefer to use software heads-on.

The central window of Zettlr using the dark theme

Contributing

As an Open Source application, Zettlr always welcomes contributions from the community. You do not need to know how to write code to help! A full overview over all the areas where you can help can be found in our contributing guide. Here, we introduce you to the two biggest areas where we welcome help: translations and contributing code.

Translating

The development team maintains the English and German translations, but lacks adequate knowledge of other languages. All the other available translations have been created by our community.

Zettlr's translations utilize the gettext system. This means that the translations are kept in PO-files within the static/lang directory.

To update a translation, simply download the corresponding language file and edit it. You can edit PO-files with a simple text editor, but if you prefer a more comfortable graphical editor, there are many out there. One good option is the Open Source editor POedit.

As soon as you are happy with your changes, open a Pull Request here that updates the corresponding file. GitHub has created a great guide on how to open Pull Requests.

Contributing Code

Zettlr is an Electron-based app, so to start developing, you'll need to have the following installed on your computer:

  1. NodeJS. Make sure it's at least Node 20 (lts/iron). To test what version you have, run node -v.
  2. Yarn. This is the package manager for the project, as we do not commit package-lock.json-files and many commands require yarn. You can install this globally using npm install -g yarn or Homebrew, if you are on macOS.
  3. On Windows, we recommend to install the Windows Subsystem for Linux (WSL), which will make many of the next steps easier.
  4. A few command-line utilities that various scripts require for running the development builds:
    • cURL (required by the Pandoc download script)
    • unzip (required by the Pandoc download script)
    • jq (required by the i18n script)
  5. An appropriate build toolchain for your operating system, since Zettlr requires a few native C++-modules that must be compiled before running the app:
    • macOS: On macOS, installing the XCode command-line tools via xcode-select --install suffices
    • Windows: On Windows, you'll need the free Visual Studio development tools that include the required tools
    • Linux: On Linux, there are a variety of compatible toolchains available, sometimes they are already preinstalled. Refer to your distribution's manual for more information.

Then, simply clone the repository and install the dependencies on your local computer:

$ git clone https://github.com/Zettlr/Zettlr.git
$ cd Zettlr
$ yarn install --immutable

The --immutable flag ensures that yarn will stick to the versions as listed in the yarn.lock and not attempt to update them.

During development, hot module reloading (HMR) is active so that you can edit the renderer's code easily and hit F5 after the changes have been compiled by electron-forge. You can keep the developer tools open to see when HMR has finished loading your changes.

What Should I Know To Contribute Code?

In order to provide code, you should have basic familiarity with the following topics and/or manuals (ordered by descending importance):

Tip

See the "Directory Structure" section below to get an idea of how Zettlr specifically works.

Development Commands

This section lists all available commands that you can use during application development. These are defined within the package.json and can be run from the command line by prefixing them with yarn. Run them from within the base directory of the repository.

start

Use this command to carefree test any changes you make to the application. This command will start the application, but will provide a custom configuration and a custom directory. Thus, it will not touch any files that a regular Zettlr installation will use.

The first time you start this command, pass the --clean-flag to copy a bunch of test-files to your ./resources-directory, create a test-config.yml in your project root, and start the application with this clean configuration. Then, you can adapt the test-config.yml to your liking (so that certain settings which you would otherwise always set will be pre-set without you having to open the preferences).

Whenever you want to reset the test directory to its initial state (or you removed the directory, or cloned the whole project anew), pass the flag --clean to the command in order to create or reset the directory. This is also necessary if you changed something in test-config.yml.

If you want to prevent a config-file from being created (e.g., to simulate the first start experience), you can pass the flag --no-config to this command.

You can pass additional command-line switches such as --clear-cache to this command as well. They will be passed to the child process.

Warning

Attention: Before first running the command, you must run it with the --clean-flag to create the directory in the first place!

Additionally, have a look at our full development documentation.

package

Packages the application, but not bundle it into an installer. Without any suffix, this command will package the application for your current platform and architecture. To create specific packages (may require running on the corresponding platform), the following suffixes are available:

  • package:mac-x64 (Intel-based Macs)
  • package:mac-arm (Apple Silicon-based Macs)
  • package:win-x64 (Intel-based Windows)
  • package:linux-x64 (Intel-based Linux)
  • package:linux-arm (ARM-based Linux)

The resulting application packages are stored in ./out.

Important

This command will skip typechecking to speed up builds, so we recommend running lint before packaging to ensure that there are no errors.

release:{platform-arch}

Packages the application and then bundles it into an installer for the corresponding platform and architecture. To create such a bundle (may require running on the corresponding platform), one of the following values for {platform-arch} is required:

  • release:mac-x64 (Intel-based Macs)
  • release:mac-arm (Apple Silicon-based Macs)
  • release:win-x64 (Intel-based Windows)
  • release:linux-x64 (Intel-based Linux)
  • release:linux-arm (ARM-based Linux)

The resulting setup bundles are stored in ./release.

Note

While you can package directly for your platform without any suffix, you need to specify the platform and architecture when creating a release bundle, since electron-builder would otherwise include the development-dependencies in the app.asar, resulting in a bloated application.

csl:refresh

This downloads the Citation Style Language (CSL) files with which the application is shipped, and places them in the static/csl-locales- and static/csl-styles-directories respectively.

Note

This command is intended for an automated workflow that runs from time to time on the repository to perform this action. Do not commit updated files to the repository. Instead, the updated files will be downloaded whenever you git fetch.

lint

Runs ESLint. Apps such as Visual Studio Code will automatically run ESLint in the background on your open files. This command runs them across the entire code base. Make sure to run this command prior to submitting a Pull Request.

Note

This command will run automatically on each Pull Request to check your code for inconsistencies.

shortcut:install

Creates a .desktop-file into your applications which enables you to quickly start an app that you have compiled from source. This requires Linux. To use new changes, simple sync the repository, run package again, and you're good to go.

Warning

We provide this command as a convenience. Unless you know what you are doing, you should not run code directly compiled from the HEAD commit of the develop branch. This command can be useful, however, in a few instances where you know what may go wrong and can take appropriate precautions.

shortcut:uninstall

Removes the .desktop-file created by shortcut:install.

Note

You don't have to uninstall and reinstall the shortcut whenever you compile the binary anew. Just make sure that Zettlr is closed before you recompile it. You should only have to reinstall the shortcut if the template (in scripts/assets/zettlr-dev.desktop) has changed.

test

This runs the unit tests in the directory ./test. Make sure to run this command prior to submitting a Pull Request, as this will be run every time you commit to the PR, and this way you can make sure that your changes don't break any tests, making the whole PR-process easier.

test-gui

See start.

Important

This command is deprecated and only an alias for start. Use start instead.

Directory Structure

Zettlr is a mature app that has amassed hundreds of directories over the course of its development. Since it is hard to contribute to an application without any guidance, we have compiled a short description of the directories with how they interrelate.

.
├── out                         # Contains unpackaged binaries after running any `package` command
├── release                     # Contains distributables after running any `release` command
├── resources                   # General resource files
│   ├── NSIS                    # Windows installer bitmaps
│   ├── icons                   # Various icon formats
│   ├── screenshots             # Contains the main screenshots
├── scripts                     # Scripts used during the build process and CI pipeline 
│   ├── assets                  # Assets for the script files
│   └── test-gui                # A full file tree used with the `test-gui` command
├── source                      # This is the actual source filetree
│   ├── app                     # Main process components
│   │   ├── service-providers   # Service providers that handle most of the business logic
│   │   └── util                # Utility functions for the main process
│   ├── common                  # Shared files between various renderer processes
│   │   ├── img                 # Images used in various places
│   │   ├── modules             # Shared modules
│   │   │   ├── markdown-editor # Main Markdown editor
│   │   │   ├── markdown-utils  # MD Utilities such as md2html converter
│   │   │   ├── preload         # Electron preload files
│   │   │   └── window-register # Run by every renderer during setup
│   │   ├── util                # General utility functions
│   │   └── vue                 # Shared Vue components
│   ├── pinia                   # Renderer state management
│   ├── types                   # Types-only directory; deprecated
│   ├── win-about               # About dialog window
│   ├── win-assets              # Assets Manager
│   ├── win-error               # Error window
│   ├── win-log-viewer          # Log Viewer
│   ├── win-main                # Main window
│   ├── win-paste-image         # Paste-Image-dialog
│   ├── win-preferences         # Preferences window
│   ├── win-print               # Print preview
│   ├── win-project-properties  # Project properties
│   ├── win-splash-screen       # The splash screen
│   ├── win-stats               # Statistics window
│   ├── win-tag-manager         # Tag manager
│   └── win-update              # Updater
├── static                      # Contains static resources
│   ├── csl-locales             # CSL locale files
│   ├── csl-styles              # CSL styles
│   ├── defaults                # Default defaults/Pandoc profiles
│   ├── dict                    # Dictionaries that ship with the app
│   ├── fonts                   # Fonts that ship with the app
│   ├── lang                    # Language and i18n-related files
│   ├── lua-filter              # Default Lua-filters
│   └── tutorial                # Tutorial files in various languages
└── test                        # Unit tests

On the Distinction between Modules and Service Providers

You'll notice that Zettlr contains both "modules" and "service providers". The difference between the two is simple: Service providers run in the main process and are completely autonomous while providing functionality to the app as a whole. Modules, on the other hand, provide functionality that must be triggered by user actions (e.g. the exporter and the importer).

The Application Lifecycle

Whenever you run Zettlr, the following steps will be executed:

  1. Execute source/main.ts
  2. Environment check (source/app/lifecycle.ts::bootApplication)
  3. Boot service providers (source/app/lifecycle.ts::bootApplication)
  4. Boot main application (source/main/zettlr.ts)
  5. Load the file tree and the documents
  6. Show the main window

And when you shut down the app, the following steps will run:

  1. Close all windows except the main window
  2. Attempt to close the main window
  3. Shutdown the main application (source/main/zettlr.ts::shutdown)
  4. Shutdown the service providers (source/app/lifecycle.ts::shutdownApplication)
  5. Exit the application

During development of the app (yarn start and yarn test-gui), the following steps will run:

  1. Electron forge will compile the code for the main process and each renderer process separately (since these are separate processes), using TypeScript and webpack to compile and transpile.
  2. Electron forge will put that code into the directory .webpack, replacing the constants you can find in the "create"-methods of the window manager with the appropriate entry points.
  3. Electron forge will start a few development servers to provide hot module reloading (HMR) and then actually start the application.

Whenever the app is built, the following steps will run:

  1. Electron forge will perform steps 1 and 2 above, but instead of running the app, it will package the resulting code into a functional app package.
  2. Electron builder will then take these pre-built packages and wrap them in a platform-specific installer (DMG-files, Windows installer, or Linux packages).

Electron forge will put the packaged applications into the directory ./out while Electron builder will put the installers into the directory ./release.

Command-Line Switches

The Zettlr binary features a few command line switches that you can make use of for different purposes.

--launch-minimized

This CLI flag will instruct Zettlr not to show the main window on start. This is useful to create autostart entries. In that case, launching Zettlr with this flag at system boot will make sure that you will only see its icon in the tray.

Since this implies the need to have the app running in the tray bar or notification area when starting the app like this, it will automatically set the corresponding setting system.leaveAppRunning to true.

Note

This flag will not have any effect on Linux systems which do not support displaying an icon in a tray bar or notification area.

--clear-cache

This will direct the File System Abstraction Layer to fully clear its cache on boot. This can be used to mitigate issues regarding changes in the code base. To ensure compatibility with any changes to the information stored in the cache, the cache is also automatically cleared when the version field in your config.json does not match the one in the package.json, which means that, as long as you do not explicitly set the version-field in your test-config.yml, the cache will always be cleared on each run when you type yarn test-gui.

Tip

If you just want to casually clear the cache for troubleshooting, you can also clear the cache by selecting the appropriate menu item in the "Help" menu, which saves you from having to dabble with anything technical.

--data-dir=path

Use this switch to specify a custom data directory, which holds your configuration files. Without this switch, the data directory defaults to %AppData%/Zettlr (on Windows 10 and newer), ~/.config/Zettlr (on Linux), or ~/Library/Application Support/Zettlr (on macOS). The path can be absolute or relative. Basis for the relative path will be either the binary's directory (when running a packaged app) or the repository root (when running an app that is not packaged). Remember to escape spaces or quote the path, if necessary. The ~ character to denote the home directory is not expanded in this case, so make sure to pass the entire path to your home directory if necessary. Due to a minor bug in Electron, an empty Dictionaries subdirectory is created in the default data directory, but it does not impact functionality.

--disable-hardware-acceleration

This switch causes Zettlr to disable hardware acceleration, which could be necessary in certain setups. For more information on why this flag was added, see issue #2127.

VSCode Extension Recommendations

This repository makes use of Visual Studio Code's recommended extensions feature. This means: If you use VS Code and open the repository for the first time, VS Code will tell you that the repository recommends to install a handful of extensions. These extensions are recommended if you work with Zettlr and will make contributing much easier. The recommendations are specified in the file .vscode/extensions.json.

Since installing extensions is sometimes a matter of taste, we have added short descriptions for each recommended extension within that file to explain why we recommend it. This way you can make your own decision whether or not you want to install any of these extensions (for example, the SVG extension is not necessary if you do not work with the SVG files provided in the repository).

If you choose not to install all of the recommended extensions at once (which we recommend), VS Code will show you the recommendations in the extensions sidebar so you can first decide which of the ones you'd like to install and then manually install those you'd like to have.

Tip

Using the same extensions as the core developer team will make the code generally more consistent since you will have the same visual feedback.

License

This software is licensed via the GNU GPL v3-License.

The brand (including name, icons and everything Zettlr can be identified with) is excluded and all rights reserved. If you want to fork Zettlr to develop another app, feel free but please change name and icons. Read about the logo usage.

zettlr's People

Contributors

a1808951 avatar actions-user avatar aigeruth avatar brli avatar cdaven avatar cskeogh avatar dependabot-preview[bot] avatar dependabot[bot] avatar derkness avatar derwok avatar edgartang avatar framatophe avatar joryschossau avatar kaan0200 avatar kangie avatar kyaso avatar mygoditsfull0fstars avatar nathanlesage avatar newhinton avatar ratherto avatar redsandro avatar ryota-abe avatar s3686814 avatar tamilneram avatar tobiasdiez avatar ufomelkor avatar vijoc avatar waterfallpit avatar weiqinyang97 avatar wieke 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  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

zettlr's Issues

Bug: Math rendering

Math rendering seems arbitrary and sometimes behaves in unwanted ways. Getting out of preview also seems arbitrary. In my case, text following a simple line such as
Xh @ Y $/h = Y$
renders everything following Y in math mode. Not sure what triggers the math rendering but it it annoying and affects readability.

Feature Request: AutoSave and Revert Button

Please add an option to autosave documents when edited, so that I do not have to explicitly click the save button. If anything, I would want a revert button to undo autosaved changes since I last clicked the save button. It's more likely that I want the document saved when I exit, and very infrequently, I want to revert those changes when I mess up my document.

Combined preview and directory pane as option

I have tried the current development version. In my opinion, the new "Combined preview and directory pane"-feature is impractical for the workflow. Can you please make it optional via settings?

Allow option of Natural or ASCIIbetical sorting for document previews

I am using Zettlr under Windows 10, and I am experiencing the infamous ASCIIbetical vs Natural sort order issue in the Zettlr preview pane. Windows Explorer implements Natural sort order, but it seems Zettlr is offering only ASCIIbetical or filesize. For info on this, see Sorting for humans, and here for a solution in JavaScript. The precise details of my issue are below.

I have a document made up of several sections, named like this (I've missed out intermediate files):

§0 Introduction.md
§10 Of modernity....md
§20 The Table of Dreams.md
§30 The degradation of language.md.
… …
§100 Pizza, birra, faso (1997).md
§110 Mundo grúa (1999).md
§120 Cultured_Cities.md
§130 Works Cited.md

When I look at these files in Windows File Explorer, they are in Natural order (when ordering by title). However, when I look at them in the Zettlr document preview, the order is ASCIIbetical, i.e. 0, 10, 100, 110, 120, 130, 20, 30. When I hover over the top of the pane, there are two buttons, one showing A-Z, which gives the non-natural order. The other shows increasing line sizes, and that one gives what I think is an ordering by file size.

Lastly, with a PowerShell one-liner I can easily compile all the *.md files to a single document in Natural order with pandoc, but I'd like to be able to see them in Natural order in Zettlr, otherwise it is difficult to work with the files! Clearly this should be a user-selectable option, because not all filesystems implement Natural sorting order.

To be clear, I think the JavaScript solution for sorting the array of files is:

var collator = new Intl.Collator(undefined, {numeric: true, sensitivity: 'base'});
var myArray = ['1_Document', '11_Document', '2_Document'];
console.log(myArray.sort(collator.compare));

… but I haven't tested it.

BUG: Unwanted file deletion when mass updadting files while Zettlr is open

Description

When Zettlr is open and showing a document in a project directory, and if another process mass-updates files (e.g. mass-reverting uncommitted changes in git, mass-updating files using find + sed in a bash shell, etc.), Zettlr seems to get overwhelmed with the number of changes, and deletes some of the files. Fortunately I have not lost files, because I have git running on my important markdown folder.

Reproducing

Method 1: Have a git-controlled directory with a Zettlr project containing a large number of files in directories and subdirectories (I don't know how many required to reproduce, but I have more than 20). One of the files should be open in Zettlr. Each file should have a minor change you don't care about. Use git / GitHub desktop, to revert all changes at once. Zettlr asks if you want to reload the currently open file. Its screen fills with "File changed by external process" (or similar message). Shortly after, check in Git, and some of the files (not all) will have been deleted subsequent to the revert.

Method 2: Have a set of 20 or so utf8 markdown files with a BOM in a project directory that is open in Zettlr (with one of the files open in editor). Using a bash shell (I'm using WSL), run
find -iname \*.md -type f -exec sed -i '1s/^\(\xef\xbb\xbf\)\?//' {} +
(This removes the BOM, if present, on all files.) Zettlr detects the change and asks to reload current file, while its display fills with messages about changed files. Check in Git. Apart from the changes to each file, you will see that some of the files are also deleted.

The deletions do not occur if Zettlr is closed.

Expected behaviour

Reload the currently open file, and not touch the others.

Platform

  • OS: Windows 10
  • OS Version: 1803
  • Zettlr Version: 0.20

Additional information

I only tested under Windows. I reproduced it when mass-updating in three scenarios: mass-updating with GitHub Desktop; mass-updating using the WSL bash shell; mass-updating files using a PowerShell script. In each case, the deletions occur only while Zettlr is open.

Workaround

Remember to close Zettlr before doing mass operations on files!

Feature: disable automatic entry of "matching characters"

I find that some characters which get automatically entered (for example, when I type `, a matching ` gets inserted automatically after cursor position) give me more trouble than benefit: I often have to edit them afterwards, which can get twiddly, and kinda interferes with my "flow" of writing. Personally, I'd prefer to disable this feature; I'm a fast typer, so it's not a trouble for me to enter the matching characters by hand.

Add the ability to compile a project to docx, not just pdf

Since this can be done relatively easily in pandoc, it shouldn't be difficult to add it as an option in Zettlr. Currently, projects can only be compiled into pdf format from inside Zettlr. What I would like is for Zettlr optionally to run a command like this for me:

pandoc -s "Intro.md" "chap1.md" "chap2.md" "chap3.md" "chap4.md" "Conclusion.md" -o My_Book.docx -f markdown -t docx --standalone --top-level-division=chapter --toc

(I'm aware pandoc ignores some of those options with docx format, it's more of a wishlist!) OK, I'm lazy, I could just run it myself in pandoc, but since Zettlr is aimed at Arts and Humanities researchers, most of my colleagues and students would freak out if you ask them to run a command-line program. And most publishers unfortunately want work submitted as docx, and won't accept pdf for obvious reasons.

Preview task list as checkboxes

This is for a new Feature.

When writing taks list

- [ ] Buy milk
- [x] Buy bread
- [ ] Buy eggs

Would be great to preview it as checkboxes that we could check/uncheck only by clicking each task

  • Buy milk
  • Buy bread
  • Buy eggs

Import images

The documentation isn't very clear on how to import images into a file in Zettlr. I'm using a Windows PC for reference.

Display on lower-resolution monitor

I've been exploring Zettlr, and it looks like it could be exactly what I've been looking for as a research/writing application. The one problem I'm running into is the display. I have an older, non-widescreen monitor (19" I think) set at 1024x768 resolution, and the editor just doesn't display well on it. The amount of writing space is limited, especially given the generous margins. The lines of text display at only about seven words long, and I have to close the tree view and zoom out once or twice to get to something more usable.

I'm also finding the text itself a bit on the pale side. The lines are thinner to start with than in some fonts, and once I've zoomed out they appear closer to medium grey than to black. If some accommodation could be made to systems like mine it would make the app a lot more accessible.

A JavaScript error occurred in the main process

Description

Similar to #14, I'm getting these errors across each directory, and each file in a directory upon opening Zettlr, or when adding any new directories. The error continues:

Uncaught Exception:
Error: watch /home/jacklenox/Documents/Zettlr ENOSPC
    at _errnoException (util.js:1024:11)
    at FSWatcher.start (fs.js:1386:19)
    at Object.fs.watch (fs.js:1412:11)
...

(Let me know if you'd like full output. I can't copy/paste for some reason.)

Reproducing

It happens when opening Zettlr with any directory opened, or when adding new directories to Zettlr.

Expected behaviour

No errors.

Screenshots

screenshot from 2018-09-14 19-36-10

screenshot from 2018-09-14 19-38-31

Platform

  • OS: Pop!_OS
  • OS Version: 18.04 LTS (based on Ubuntu)
  • Zettlr Version: 0.19

Images scales to window app full width

First of all congrats for this awesome app!

I encountered a problem when previewing images because they get scalled to all window app full width.

This is a problem when makeing a document with small images.

Could you make that the images maintain their oriiginal height and width, and don't resize them to a bigger size than original ?

Of course, images may be down resized if they are bigger than the window width but please don't scale them to a bigger size.

Feature: Code Folding

I've recently discovered Zettlr, and I'm trying to use it to organize multiple, dispersed files I have into an academic book, i.e. to use Zettlr rather like Scrivener. I love the concept and what has been achieved so far with your project. One issue I've encountered at the outset: I need to rework articles and book chapters that have endnotes, and I want to work on different sections of these documents as different markdown files in a project folder, while keeping the references in a separate file in the same folder. This currently works when compiling the project to a PDF (although the endnotes all become footnotes) but of course the tooltip is empty, and it's not possible to export just a section, say, to Word with its endnotes/footnotes.

Regarding the tooltip, I'm guessing it would be relatively simple -- a case of adding some code at https://github.com/Zettlr/Zettlr/blob/develop/source/renderer/zettlr-editor.js#L545 to search the contents of a specified file for the reference note. The filename pattern would ideally need to be user-specified, as it is language dependent (e.g., I might want a filename matching /#\d+.?references/i in English, but /#\d+.?referencias/i in Spanish, or I might want /\d+.endnotes/i).

Regarding exporting a document section with notes from the references file, I imagine it's a little more complicated and would be a separate but related issue.

By the way, as an academic working in the arts (with some knowledge of JS coding), the subtle reference to Rancière on the Zettlr home page brought a smile to my face :-) .

Add Math support with Mathjax or KaTex

Hello.

I would love if this app had support for mathematical equations using LaTeX's syntax, where two dollar signs are user for inline equations: $ your formula $. And four are used for paragraph equations.

$$
your formula
$$

An example of this can found in typora.

typora

The current file has been modified remotely

I have a directory opened from my DropBox folder and each time any file that is saved, Zettlr throws me a message:

The current file has been modified remotely. Replace in editor ? And i only edit it from Zettlr

This popup message is very annoying when editing several files, because i must accept the alert each time.

Perhaps a configuration option to accept/cancel allways automatically ?

Table of Contents is not properly punctuated.

If I have say, three headings like:
# Heading 1
## Heading 2
# Heading 3

It should show under the TOC as this:

  1. Heading 1
    1.1. Heading 2
  2. Heading 3

Currently the full stops after the ordinals are missing.

ENOSPC-Errors on startup of Zettlr

Hey,

I've now received error reports from multiple persons that relate to so-called ENOSPC-errors; mainly on Linux systems, but there were instances of these errors occurring on Windows (thanks to @damien122 for reporting this in issue #13).

While I was always unsure as to why this happens, because I never experienced these errors on any platform, and they seemed to be completely random, I now know why they occur.

The errors are related to the hard-coded maximum amount of file handles that can be opened simultaneously by an app on each operating system. As has been written in this thread on StackOverflow, one could manually increase the amount of files.

But as this is unfeasible for all systems, and I don't want to mess with environment variables, there are two options:

  1. Simply notifying the user that the current directory simply contains too many files for the chokidar-plugin to use and that the directory will therefore not be monitored and external changes cannot be reflected by the app.
  2. Which I deem the better one: Throwing out chokidar in favor of a complex implementation of "pulses" that are sent through the directory trees every like 30 seconds to re-scan the contents and reflect potential changes and simply fs.watch() the currently opened file directly.

Any thoughts on that?

Don't grey-out literals (characters following a backslash)

It's fine to grey-out the backslash itself, but the character following it is a literal and therefore is intended to be what it is. For example, if I write myname\@myuniversity.ac.uk currently Zettlr greys out both the backslash and the @ sign. Now I realize I probably don't need to write @ as a literal, but pandoc seems to do it anyway when converting from other formats. Maybe a better case is this (sentence entirely fictional):

L.P. Hartley wrote that "\[t\]he past is a foreign country; they do things differently \[…\]". You will rightly complain that this quotation is incomplete, but that is my point.

Again, maybe I don't need to put the backslashes in, because it's not interpreted as an href, but pandoc puts them in to avoid ambiguity, and the result is I can hardly see the greyed out brackets in Zettlr, and they're peppered through the work I'm converting.

problems to start source code on windows

Hi,
I try to run the code on windows but get some errors while execute the command npm install after git clone.
I got the following errores:

npm ERR! code ELIFECYCLE
npm ERR! errno 1
npm ERR! [email protected] postinstall: `patch -p1 -d ../codemirror < markdown-list-autoindent.patch`
npm ERR! Exit status 1
npm ERR!
npm ERR! Failed at the [email protected] postinstall script.
npm ERR! This is probably not a problem with npm. There is likely additional logging output above.

My npm and node version are:
node v8.9.4
npm v5.4.2

and some verbose log:

14157 verbose stack Error: [email protected] postinstall: `patch -p1 -d ../codemirror < markdown-list-autoindent.patch`
14157 verbose stack Exit status 1
14157 verbose stack     at EventEmitter.<anonymous> (C:\Users\XXX\AppData\Roaming\npm\node_modules\npm\node_modules\npm-lifecycle\index.js:280:16)
14157 verbose stack     at emitTwo (events.js:126:13)
14157 verbose stack     at EventEmitter.emit (events.js:214:7)
14157 verbose stack     at ChildProcess.<anonymous> (C:\Users\XXX\AppData\Roaming\npm\node_modules\npm\node_modules\npm-lifecycle\lib\spawn.js:55:14)
14157 verbose stack     at emitTwo (events.js:126:13)
14157 verbose stack     at ChildProcess.emit (events.js:214:7)
14157 verbose stack     at maybeClose (internal/child_process.js:925:16)
14157 verbose stack     at Process.ChildProcess._handle.onexit (internal/child_process.js:209:5)
14158 verbose pkgid [email protected]

Also in my Linux environment on windows (WSL) I can't start the code with following errors:

17463 verbose lifecycle [email protected]~postinstall: unsafe-perm in lifecycle true
17464 verbose lifecycle [email protected]~postinstall: PATH: /usr/lib/node_modules/npm/node_modules/npm-lifecycle/node-gyp-b$
17465 verbose lifecycle [email protected]~postinstall: CWD: /tmp/Zettlr
17466 silly lifecycle [email protected]~postinstall: Args: [ '-c', 'electron-builder install-app-deps' ]
17467 silly lifecycle [email protected]~postinstall: Returned: code: 126  signal: null
17468 info lifecycle [email protected]~postinstall: Failed to exec postinstall script
17469 verbose stack Error: [email protected] postinstall: `electron-builder install-app-deps`
17469 verbose stack Exit status 126
17469 verbose stack     at EventEmitter.<anonymous> (/usr/lib/node_modules/npm/node_modules/npm-lifecycle/index.js:285:1$
17469 verbose stack     at emitTwo (events.js:126:13)
17469 verbose stack     at EventEmitter.emit (events.js:214:7)
17469 verbose stack     at ChildProcess.<anonymous> (/usr/lib/node_modules/npm/node_modules/npm-lifecycle/lib/spawn.js:5$
17469 verbose stack     at emitTwo (events.js:126:13)
17469 verbose stack     at ChildProcess.emit (events.js:214:7)
17469 verbose stack     at maybeClose (internal/child_process.js:925:16)
17469 verbose stack     at Process.ChildProcess._handle.onexit (internal/child_process.js:209:5)
17470 verbose pkgid [email protected]
17471 verbose cwd /tmp/Zettlr
17472 verbose Linux 4.4.0-43-Microsoft
17473 verbose argv "/usr/bin/node" "/usr/bin/npm" "install"
17474 verbose node v8.9.4
17475 verbose npm  v5.6.0
17476 error code ELIFECYCLE
17477 error errno 126
17478 error [email protected] postinstall: `electron-builder install-app-deps`
17478 error Exit status 126

Thanks for your help.

Deb Package for 0.15.2 corrupted

When I try to install/update current deb package via "dpkg --install Zettlr-linux-x64-0.15.2.deb", I get the following error message:

decompressing archive member: lzma error: compressed data is corrupt
dpkg-deb: error: subprocess returned error exit status 2
dpkg: error processing archive Zettlr-linux-x64-0.15.2.deb (--install):
cannot copy extracted data for './opt/Zettlr/zettlr' to '/opt/Zettlr/zettlr.dpkg-new': unexpected end of file or stream

I downloaded it serveral times with different browsers, tried to install it with gdebi, nothing works. So i assume the deb package ist corrupted.

Error generating PDF: "A JavaScript error occurred in the main process"

Error on generating PDF

Uncaught Exception: Export failed: An error occurred on export: Error: Command failed: pandoc "/var/folders/sj/mnk7m9s114sc__bh8ykbjxb80000gq/T/export.tmp" -f markdown --template="/var/folders/sj/mnk7m9s114sc__bh8ykbjxb80000gq/T/template.latex" --pdf-engine=xelatex -o "/var/folders/sj/mnk7m9s114sc__bh8ykbjxb80000gq/T/living-brands.pdf" Error producing PDF. ! LaTeX Error: File shading.sty not found. Type X to quit or <RETURN> to proceed, or enter new name. (Default extension: sty) Enter file name: ! Emergency stop. <read *> l.14 ^^M

I opened a note, clicked the "share the current file" icon and selected PDF

It should generate a PDF for me

Error above

Platform

  • OS: Mac OS
  • OS Version: 10.13.6
  • Zettlr Version 0.18.1

I had upgraded to 0.18.1 and had this happen. I then uninstalled completely and reinstalled fresh, same problem.

Feature request: Option to remove separation by subfolders and make Zettlr recognize double # tags

Hi. I've recently started working on implementing a zettelkasten system and discovered your app a few weeks ago been indecisive on what to use but this is pretty much what I've been looking for.

Though there are two issues that while not game-breaking are bit annoying for my zettelkasten workflow.

The first and the main one is a problem with file sorting and subfolders. I am a noob so maybe I just missed something, but while we can sort files #4 now they are still nested under subfolders if there are any. I use timestamps like 20181001174801 in file names for sorting purposes and for ID purposes.

The problem is that if I have notes "2017" "2018" "2019" "2020" "2021" (with 2019 and 2020 in a subfolder) it looks like this

"Folder"

"2017"
"2018"
"2021"

"Subfolder"

"2019"
"2020"

I want all notes in all subfolders of a given folder be in a single list so that I can fully use the sorting by timestamps. It would be nice if there was a setting for preview pane to list just the files and sort them as if there weren't subfolders.

It seems to be possible to work around this with virtual directories though it would be nice if it weren't necessary. Using this method would also be quite hassle with larger number of files, there doesn't seem to be a way to select multiple files at once, or maybe again I am a noob and just missed something.

The second lesser issue is with tags. Since you are familiar zettelkasten you may have seen some people use tags like ##sometag instead of #sometag for overview notes and special stuff.

The way it is now Zettlr will recognize a tag but it will ignore the first hashtag so this is the result ##sometag. You can get around this by putting the whole thing in global search but It would be good if Zettlr recognized these tags, these tags should othewise act like normal tags.

On another note I just want to say that I've tested the app 10 000 dummy md files (in a single folder) and it worked quite good did the same with 20 000 still worked quite good, today I tested it with 30 000 and searched for "the" in every file and while of course it did take some time it worked.

I've tested up to 20 000 QOwnNotes Atom, VSCode and Rene's sublimeless Zk.

Zettlr and QOwnNotes seemed to have best perfomance (though it took a little while for QOwnNotes to launch with that many files it ran smooth afterwards) similar with Zettlr at 30 000.

No way to search and replace

Currently I can't find the functionality to search and replace with Zettlr. Maybe it's possible somehow through Regexp but alas, I have no grasp of those :D

Maybe CMD/CTRL+F to search normally (visualize how many results somewhere).

CMD+Shift+F or CMD+Shift+H (as in VSCode) to open Search and Replace.

Is this hard to implement? If you point me where the search functionality is defined, I might try to do a pull request.

Also, are you in need of localization help?

When exporting a project, footnotes in individual chapters are misplaced

Example: I have a book project with several chapters. Each chapter has its own footnotes numbered sequentially from 1 to xx. When I export the project to PDF in Zettlr, footnotes from later chapters get assigned to footnote reference markers from earlier chapters.

I realize this is more of a pandoc issue, but it would be a major show stopper for your target audience, so it's worth working around if possible. #42 might mitigate, but it doesn't solve the problem of how to get the separate chapters into Zettlr and renumber all footnotes in the first place. Also, most books by most publishers, especially edited books, restart footnote numbers per chapter. So I think this is a separate issue from #42..

Workaround 1: Under the hood, Zettlr could assign a unique chapter identifier to each note, since notes don't have to be numeric only.

Workaround 2: Use the pandoc option of writing a footnote inline using the syntax:

Some text^[Text of footnote.]

Drawback is that footnotes can't have more than one paragraph, and they clutter up the main text. Advantage is ease of writing and editing footnotes. I've tested this option, and pandoc produces correctly numbered foot-of-the-page footnotes when exporting the project.

As this is a severe "bug", I think the Export function should throw up a specific warning about footnotes needing to be unique, until Zettlr can handle this automatically.

Clicking link does not open target

Description

In Zettlr file (a) I create a link to another Zettlr file (b) using either the path or the ID.
The link turns green, confirming the path (or ID) is valid.
Clicking on the text with link, in file (a), opens the (link_path_or_ID) as text in file (a) but does not open file (b) as expected.

Using Zettlr 0.20.0 on Linux Mint 18.1

Add Tree Navigation for Tags

I would love to see a navigation area for tags in the tree view. It could include all tags used in all files in the current root folder.

Each tag could contain each other tag it is combined with. So for example:

File1.md tagged with t1, t2
File2.md tagged with t2
File3.md tagged with t2, t3

The tag tree could look like this:

|- t1
| |-t2
|-t2
| |-t1
| |-t3
|-t3
| |-t2

Clicking on a tag could issue a corresponding search for this tag / tag combination.

This is tremendously useful to structure information collected with the Zettelkasten methodology.

on footnotes: a couple of suggestions

Absolutely love this project. I am simply annoyed I didn't know about it earlier.

What I absolutely need in an editor is the ability to handle footnotes and you have that integrated nicely. It's not markdown's greatest strength but it's too often neglected. I have to suggestions for your consideration:

  1. Please, please add a shortcut for footnotes. I use them so often and I prefer not to leave the keyboard for them if possible. It does not appear that you have Ctrl+Alt+F linked to anything (and that's MS Word's shortcut) and it would be great to be able to insert it quickly.

  2. This one is a much bigger ask, but here we go. Since you aim (Thank you!) for the humanities, you know that we use a lot of notes. If at all possible, it would be great to be able to have the footnotes in a sidebar and not right below the text. That would be an improvement even on MS Word in my opinion.

Thank you greatly for this project.

Dissemination of the app to repositories (Brew Cask, Launchpad, etc.)

Description

The app is currently only available through Github and/or website download.

Reproducing

Expected behaviour

A cask for downloading/installing the app through cask would be great!

Screenshots

Platform

  • OS: [e.g. iOS] macOS
  • OS Version [e.g. 11] Doesn't matter
  • Zettlr Version [e.g. 0.15] Latest
  • Screen Resolution [only necessary if the bug is relating to the GUI]

Additional information

Would be great for people which streamlined their macOS setup with homebrew / cask.

Discussion: Grab Bag of Topics, Partially in Response to Issue #9

Hello Nathan,

Unfortunately, there is no good way to keep these items separate, and it focuses more on how I think of the scope of Zettlr. So this will be a longer post, and hopefully can spur further discussions as separate topics when focusing more on implementation. The overarching theme in this post is that we should treat documents as tasks, so that we can have Zettlr help you better manage when you work on and review documents.

Unlike many apps that are trying to solve problems of editing text or introduce a novel but difficult technology, I think of Zettlr as a tool focused on facilitating the writing process, and features built into the app should be built around that.

The most comparable app I can think of which takes a very similar approach (with a slightly larger scope) on mobile devices is Matcha (http://www.matchaapp.com/), and I and the developer have spent a lot of time thinking through different features of the app, some of which might also translate well to Zettlr, and I thought I would add them here.


But first, I'll focus a bit on tabbed view, which we had started discussing in issue #9. I like apps that present documents that may be relevant to me for what I am doing. That is the very reason why I dislike the way tabs are usually used, to keep all documents that might be of interest open. You ultimately end up with any document from any context that might be of importance, and it becomes a mess. Tabs are not designed for context, but for quick access to everything. They deter you from staying focused.

A file tree kind of works that way, but still does not filter the document list enough. Any document of relevance to a context would be located in the folder of consideration, and the few documents of importance are scattered amongst them. Explicitly identifying the few documents of importance helps you quickly shift between important documents needed in a context. Marking documents as starred with metadata (starred: yes is added at the top of the document as a multimarkdown metadata) addresses this somewhat, but the importance of a documents changes with respect to time and with respect to other documents and folders. So instead, I propose a pin to metadata be recognized in Zettlr (which we had started implementing in Matcha). Here are some examples:

pin-to: morning
pin-until: 2018-03-31
pin-to: folder(project1)
pin-to: document(task-list.markdown)
pin-between: 2018-02-26 to 2018-03-31
pin: always

This metadata could show the documents in a calendar view, at the top of the preview pane in specific folders, or in something like a research sidebar we discussed.

Basically, you are able to say when a document should be considered as important, and when it is, it would be emphasized by Zettlr. To make it easier to cross-reference documents and folders in metadata and while writing, we also have considered allowing users to add a user-assigned label/short-hand to the file name or metadata. For example, in the file name "[ShortFileName] - fullFileName.md", you could use [ShortFileName] as an alias to refer to the document "[ShortFileName] - fullFileName.md" within a markdown file, with the following syntax (ex. "pin-to: [[ShortFileName]]"). You can do the same thing with folders, and chain labels/short-hand together to make reference from other folders quick ([ShortFolderName][ShortFileName].


Similarly, I noticed that Zettlr had a pomodoro timer. It's an interesting scope added to Zettlr, that could be extended further. I would suggest adding more features to enable Zettlr to enable Zettlr to suggest documents to work on. Treat documents like tasks, that can be assigned to checklists and a calendar. You could have Zttlr to show you documents you need to finish in the next week, and documents that you should review in the morning, or on a certain date.

Some text in preformatted code blocks gets extra unwanted formatting

Description

Text in the "code blocks" is sometimes over-eagerly formatted (as Markdown). Those blocks should rather be exempt from any formatting, other than making the font fixed width.

Reproducing

Type the following markdown into Zettlr:

# Problems in code blocks
```
Some Markdown is still parsed in code blocks. Especially problematic for
comments in scripting languages:
# this gets converted to a heading
int main() {
  <- two spaces here, but looks like less (should start on "t" in "int" above)
  if (false) {
    exit(1);
  }
}
// Ascii art doesn't render well as a result:
                   .-.  .-.
                  |   \/   |
                  \        /
                   `\    /`
               jgs   `\/`
// Hyperlinks are highlighted, which is comparatively a minor complaint; it
// mostly only makes some code look weird (though also breaks fixed-width property)
const char *address = "http://www.oocities.org/spunk1111/small.htm";
```

Instead of being formatted fully with fixed-width, fixed-size font, some areas of the block get formatted with variable-size and variable-width font. More details are present in the text of the block above, as well as in the attached screenshot further below. Specifically, what I noticed:

  • lines starting with # are formatted as headings;
  • on lines starting with whitespace (indented lines), the whitespace width does not match the width of non-whitespace characters in the fixed-width font;
  • URLs are formatted with variable-width font, and different font size & color.

Expected behaviour

All the text in the ```-fenced area should be formatted purely with fixed-width font, with non-variable font size.

Screenshots

zettlr-code-blocks

Platform

  • OS: Ubuntu Linux
  • OS Version: Ubuntu 16.04.5 LTS
  • Zettlr Version: 0.19.0
  • Screen Resolution [only necessary if the bug is relating to the GUI]

Feature Request: Distraction-Free Mode

A Distraction-free mode would keep the focus on the editor and hide other unnecessary UI elements until you exit the mode. User could select to dim text not in the same sentence or paragraph as the cursor is currently on while this mode is active.

Feature Request: Inline Image and Table Preview

It would be great if you could show a preview of images or tables added tot the document within the editor. Not sure what the best way to approach it would be, though. I was thinking of a tiny unobtrusive button next to images and tables you could click for a preview, or maybe hovering over it.

What Regular Data is Sent from us by Zettlr via internet?

I noticed Zettlr regularly needs to send data over the internet protocols.

Q1: What Regular Data is Sent from us by Zettlr via internet?

Q2: is it sent by secure protocls

Q3: What user data do you keep?

I have disabled data transfer by Zettlr with the Comodo Firewall until I find out what data is being transferred..

Thanks.

ability to follow links (especially inter-document links)

I'm interested in having the ability to follow links in Markdown documents, especially links to other Markdown documents that are contained in the same directory.

I have a set of Markdown documents that I keep notes in, and they have links to each other in them. I also have a table of contents Markdown document that links to all of the others.

Currently, I can do this with Visual Studio Code and Notepad++. For Notepad++ the "open file" command (ctrl + j by default) will follow markdown links.

I would much prefer to use an actual Markdown editor (like Zettlr) for these documents.

Thanks!

Footnotes are misinterpreted when in close proximity to links

Description

Footnotes are not displayed properly when there is a […](...) link in the same sentence.

Reproducing

Paste the following real-world example textually into a new Zettlr document:

This is a form of *bricolage*, to use the term Jacques Derrida adopted from Claude Lévi-Strauss.[^1] Indeed, it aims to make the *bricolage* process explicit, a form of [autopoietic](https://en.wikipedia.org/wiki/Autopoiesis) writing.

[^1]: Derrida, Jacques, “Structure, Sign and Play in the Discourse of the Human Sciences”, *Writing and Difference*, trans. by Alan Bass (London: Routledge, 2005 \[1967\]), pp. 351-70 (360ff).

In Zettlr, visually it looks like this:
image

Expected behaviour

Show the footnote correctly, and not assume it is part of the hyperlink.

Screenshots
See above.

Platform

  • OS: Windows 10
  • OS Version: 1803
  • Zettlr Version: 0.20.0

Follow resolvable hyperlinks

Pandoc creates a table of contents for a markdown file (using the switch --toc), in which internal document links look like this:

[Tangos, photography, and film](#tangos-photography-and-film)

It would be brilliant if Zettlr were able to follow such links. It would need to use the same algorithm as pandoc for omitting punctuation, etc., but since Zettlr already has the logic to search for tags, it's really just a case of adapting the existing logic with a dynamically constructed regex successively matching a # and then the parts between the hyphens along the same line.

On a similar vein, but in this case linking to other files, it is a bit surprising that Zettlr can follow a link to another file constructed with Wiki-style links like this:

[[My awesome markdown file]]

… but it can't follow a link with a more standard markdown syntax like this:

(The greatest document of all)[My awesome markdown file]

In fact I can't get it to follow relative hyperlinks at all, no matter how I construct them. Could the second syntax be supported, and ideally also support actual relative hyperlinks of the type
(link)[my subdirectory/my file.md]?

Feature Request: Attachment Pane

It would be great to have a pane to the right of the editor that could show attachments like pdfs and images that exist in the same folder and subfolders of the document open. Double clicking on the attachment would open it in the system viewer.

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.