electron/docs/glossary.md
Zeke Sikelianos ed081c8834 WIP
2016-12-21 13:47:40 -08:00

109 lines
4.2 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# Glossary
This page defines some terminology that is commonly used in Electron development.
## ASAR
ASAR stands for Atom Shell Archive Format. An [asar][asar] archive is a simple
`tar`-like format that concatenates files into a single file. Electron can read
arbitrary files from it without unpacking the whole file.
The ASAR format was created primarily to improve performance on Windows... TODO
## Brightray
Brightray is a static library that makes [libchromiumcontent] easier to use in
applications. It was created specifically for Electron, but can be used to
enable Chromium's renderer in native apps that are not based on Electron.
Brightray is a low-level dependency of Electron that does not concern the
majority of Electron users.
## IPC
IPC stands for Inter-Process Communication. Electron uses IPC to send
serialized JSON messages between the [main] and [renderer] processes.
## libchromiumcontent
A single, shared library that includes the Chromium Content module and all its
dependencies (e.g., Blink, [V8], etc.).
## Main Process
The main process, commonly a file named `main.js`, is the entry point to every
Electron app. It controls the life of the app, from open to close. It also
manages native elements such as the Menu, Menu Bar, Dock, Tray, etc. The
main process is responsible for creating each new renderer process in the app.
The full Node API is built in.
Every app's main process file is specified in the `main` property in
`package.json`. This is how `electron .` knows what file to execute at startup.
## MAS
Acronym for Apple's Mac App Store. For details on submitting your app to the
MAS, see the [Mac App Store Submission Guide].
## Native Modules
Native Modules (also called [addons] in
Node.js) are modules written in C or C++ that can be loaded into Node.js or
Electron using the require() function, and used just as if they were an
ordinary Node.js module. They are used primarily to provide an interface
between JavaScript running in Node.js and C/C++ libraries.
Native Node modules are supported by Electron, but since Electron is very
likely to use a different V8 version from the Node binary installed in your
system, you have to manually specify the location of Electrons headers when
building native modules.
See also [Using Native Node Modules]
## Renderer Process
The renderer process is a browser window in your app. Unlike the main process,
there can be multiple of these and each is run in a separate process.
They can also be hidden.
In normal browsers, web pages usually run in a sandboxed environment and are not
allowed access to native resources. Electron users, however, have the power to
use Node.js APIs in web pages allowing lower level operating system
interactions.
## Squirrel
Squirrel is an open-source framework that enables Electron apps to update
automatically as new versions are released. See the [autoUpdater] API for
info about getting started with Squirrel.
## userland
This term originated in the Unix community, where "userland" or "userspace"
referred to programs that run outside of the operating system kernel. More
recently, the term has been popularized in the Node and npm community to
distinguish between the features available in "Node core" versus packages
published to the npm registry by the much larger "user" community.
Just like Node, Electron is focused on having a small set of APIs that provide
all the necessary primitives for developing multi-platform Desktop applications.
This design philosophy allows Electron to remain a flexible tool without being
overly prescriptive about how it should be used. Userland enables users to
create and share tools that provide additional functionality on top of what is
available in "core".
## V8
V8 is Google's open source JavaScript engine. It is written in C++ and is
used in Google Chrome, the open source browser from Google. V8 can run
standalone, or can be embedded into any C++ application.
[addons]: https://nodejs.org/api/addons.html
[autoUpdater]: api/auto-updater.md
[libchromiumcontent]: #libchromiumcontent
[Mac App Store Submission Guide]: tutorials/mac-app-store-submission-guide.md
[main]: #main-process
[renderer]: #renderer-process
[Using Native Node Modules]: tutorial/using-native-node-modules.md
[userland]: #userland
[V8]: #v8