## File: README.md [](https://github.com/brndnmtthws/conky/actions/workflows/build-and-test-linux.yaml) [](https://github.com/brndnmtthws/conky/actions/workflows/build-and-test-macos.yaml) [](https://github.com/brndnmtthws/conky/actions/workflows/docker.yaml) [](https://github.com/brndnmtthws/conky/actions/workflows/publish-appimage.yml) [📕 Documentaton](https://conky.cc/) [💬 Join the Matrix chat](https://matrix.to/#/#conky:frens.io) **Conky** is a free, light-weight system monitor for X, that displays any kind of information on your desktop. It can also run on Wayland (with caveats), macOS, output to your console, a file, or even HTTP (oh my!). 👉 Grab the [latest release from GitHub](https://github.com/brndnmtthws/conky/releases/latest). [📹 An introduction to Conky (YouTube)](https://www.youtube.com/watch?v=bHtpLEoRKmg&t=19s). ## Features Conky can display more than 300 built-in objects, including support for: - A plethora of OS stats (uname, uptime, **CPU usage**, **mem usage**, disk usage, **"top"** like process stats, and **network monitoring**, just to name a few). - Built-in **IMAP** and **POP3** support. - Built-in support for many popular music players ([MPD][], [XMMS2][], [Audacious][]). - Can be extended using built-in [**Lua**][luawiki] support, or any of your own scripts and programs ([more](https://github.com/brndnmtthws/conky/wiki#tutorial)). - Built-in [**Imlib2**][imlib2] and [**Cairo**][cairo] bindings for arbitrary drawing with Lua ([more](https://github.com/brndnmtthws/conky/wiki/Lua)). - Runs on Linux, FreeBSD, OpenBSD, DragonFlyBSD, NetBSD, Solaris, Haiku, and macOS! - [Docker image](https://hub.docker.com/r/brndnmtthws/conky/) available for amd64, armv7, and aarch64 (aka armv8) ... and much much more. Conky can display information either as text, or using simple progress bars and graph widgets, with different fonts and colours, as well as handle [mouse events](https://github.com/brndnmtthws/conky/wiki/Mouse-Events). ## Screenshots [](https://raw.github.com/wiki/brndnmtthws/conky/configs/brenden/screenshot.png) [](https://raw.github.com/wiki/brndnmtthws/conky/configs/ke49/screenshot.png) [](https://raw.github.com/wiki/brndnmtthws/conky/configs/jc/screenshot.png) See the User Configs below for more screenshots and associated config files. ## Installing Conky Many package managers already include Conky. However, if you'd like to try the latest version of Conky, you can use the AppImage or the Nix flake. ### AppImage To try the AppImage, head to and fetch the latest AppImage. You'll need to set the executable bit, then you can create a conkyrc, and run it as follows: ```ShellSession chmod +x ./conky-*.AppImage # make it executable ./conky-*.AppImage -C > ~/.conkyrc # create a default config ./conky-*.AppImage # run ``` And that's it! [Check out the Wiki](https://github.com/brndnmtthws/conky/wiki) for more details on configuring Conky. _NOTE_: To use the AppImage, you may need to install additional runtime libraries. ### Nix flake As of Conky v1.17.0, there's a Nix flake available in addition to the upstream Nix package. You can include it as an input as follows: ```nix { inputs = { conky.url = "github:brndnmtthws/conky"; }; } ``` And use `inputs.conky.packages.${system}.default` (or `inputs.conky.packages.${system}.conky` for versions <=v1.19.8) to include the package. To use a specific version, add the git tag to the URL, such as `github:brndnmtthws/conky?ref=refs/tags/v1.19.8`. Note that a Nix package [exists in nixpkgs](https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/os-specific/linux/conky/default.nix), and although it's not always up-to-date with the bleeding edge, it does offer more configuration options. ## Documentation → [**Reference documentation**](https://conky.cc/) ← The [Conky Wiki](https://github.com/brndnmtthws/conky/wiki) also serves as a central hub for Conky. Some resources from the Wiki include: - [Installation](https://github.com/brndnmtthws/conky/wiki/Installation) - [Configuration Settings](https://github.com/brndnmtthws/conky/wiki/Configurations) - [Community Configs](https://github.com/brndnmtthws/conky/wiki/Community-Configurations) - [Frequently Asked Questions](https://github.com/brndnmtthws/conky/wiki/FAQ) ## Development setup Conky uses [mise](https://mise.jdx.dev/) to pin developer tools such as CMake, Ninja, Bun, uv, and lefthook. After installing mise, bootstrap the toolchain from the repository root: ```sh mise install mise run doctor ``` `mise run doctor` checks for native libraries that still come from your system package manager, such as X11, Cairo, Lua, Imlib2, librsvg, ncurses, and libxml2. Once it passes, use the mise tasks for the normal development loop: ```sh mise run configure mise run build mise run test ``` If your shell has `mise activate` enabled, entering the repository runs `mise i -q` automatically. Tool downloads are locked by `mise.lock`; update the lockfile with `MISE_LOCKED=0 mise lock` after changing tool versions. ## License Conky is licensed under the terms of the [GPLv3](LICENSE) license. ## Contributing Contributions are welcome from anyone. Please read [Contributing](https://github.com/brndnmtthws/conky/wiki/Contributing) page on wiki for guidelines on contributing to Conky. [mpd]: https://musicpd.org/ [xmms2]: https://github.com/xmms2/wiki/wiki [audacious]: https://audacious-media-player.org/ [luawiki]: https://en.wikipedia.org/wiki/Lua_%28programming_language%29 [imlib2]: https://docs.enlightenment.org/api/imlib2/html/ [cairo]: https://www.cairographics.org/ ## Supporting this project Conky exists only through the hard work of a collection of volunteers. Please consider sponsoring the project's developers if you get value out of Conky. --- ## File: 3rdparty/toluapp/README.md [](https://travis-ci.org/brndnmtthws/toluapp) # tolua++ ## What is tolua++? tolua++ is an extension of toLua, a tool to integrate C/C++ code with Lua. tolua++ includes new features oriented to c++, such as class templates. tolua is a tool that greatly simplifies the integration of C/C++ code with Lua. Based on a "cleaned" header file, tolua automatically generates the binding code to access C/C++ features from Lua. Using Lua-5.0 API and metamethod facilities, the current version automatically maps C/C++ constants, external variables, functions, namespace, classes, and methods to Lua. It also provides facilities to create Lua modules. ## Availability tolua++ is freely available for both academic and commercial purposes. See COPYRIGHT for details. tolua++ can be downloaded from the sites below: http://www.codenix.com/~tolua/ ## Installation See INSTALL. Contacting the author tolua has been designed and implemented by Waldemar Celes. tolua++ is maintained by Ariel Manzur. Send your comments, bug reports and anything else to tolua@codenix.com --- ## File: 3rdparty/Vc/README.md **Vc is now in maintenance mode and no longer actively developed. However, we continue to review pull requests with bugfixes from the community.** **You may be interested in switching to [std-simd](https://github.com/VcDevel/std-simd).** GCC 11 includes an experimental version of `std::simd` as part of libstdc++, which also works with clang. Features present in Vc 1.4 and not present in *std-simd* will eventually turn into Vc 2.0,which then depends on *std-simd*. # Vc: portable, zero-overhead C++ types for explicitly data-parallel programming Recent generations of CPUs, and GPUs in particular, require data-parallel codes for full efficiency. Data parallelism requires that the same sequence of operations is applied to different input data. CPUs and GPUs can thus reduce the necessary hardware for instruction decoding and scheduling in favor of more arithmetic and logic units, which execute the same instructions synchronously. On CPU architectures this is implemented via SIMD registers and instructions. A single SIMD register can store N values and a single SIMD instruction can execute N operations on those values. On GPU architectures N threads run in perfect sync, fed by a single instruction decoder/scheduler. Each thread has local memory and a given index to calculate the offsets in memory for loads and stores. Current C++ compilers can do automatic transformation of scalar codes to SIMD instructions (auto-vectorization). However, the compiler must reconstruct an intrinsic property of the algorithm that was lost when the developer wrote a purely scalar implementation in C++. Consequently, C++ compilers cannot vectorize any given code to its most efficient data-parallel variant. Especially larger data-parallel loops, spanning over multiple functions or even translation units, will often not be transformed into efficient SIMD code. The Vc library provides the missing link. Its types enable explicitly stating data-parallel operations on multiple values. The parallelism is therefore added via the type system. Competing approaches state the parallelism via new control structures and consequently new semantics inside the body of these control structures. Vc is a free software library to ease explicit vectorization of C++ code. It has an intuitive API and provides portability between different compilers and compiler versions as well as portability between different vector instruction sets. Thus an application written with Vc can be compiled for: * AVX and AVX2 * SSE2 up to SSE4.2 or SSE4a * Scalar * ~~AVX-512 (Vc 2 development)~~ * ~~NEON (in development)~~ * ~~NVIDIA GPUs / CUDA (research)~~ After Intel dropped MIC support with ICC 18, Vc 1.4 also removed support for it. ## Examples ### Usage on Compiler Explorer * [Simdize Example](https://godbolt.org/z/JVEM2j) * [Total momentum and time stepping of `std::vector`](https://godbolt.org/z/JNdkL9) * [Matrix Example](https://godbolt.org/z/fFEkuX): This uses vertical vectorization which does not scale to different vector sizes. However, the example is instructive to compare it with similar solutions of other languages or libraries. * [N-vortex solver](https://godbolt.org/z/4o1cg_) showing `simdize`d iteration over many `std::vector`. Note how [important the `-march` flag is, compared to plain `-mavx2 -mfma`](https://godbolt.org/z/hKiOjr). ### Scalar Product Let's start from the code for calculating a 3D scalar product using builtin floats: ```cpp using Vec3D = std::array; float scalar_product(Vec3D a, Vec3D b) { return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; } ``` Using Vc, we can easily vectorize the code using the `float_v` type: ```cpp using Vc::float_v using Vec3D = std::array; float_v scalar_product(Vec3D a, Vec3D b) { return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; } ``` The above will scale to 1, 4, 8, 16, etc. scalar products calculated in parallel, depending on the target hardware's capabilities. For comparison, the same vectorization using Intel SSE intrinsics is more verbose and uses prefix notation (i.e. function calls): ```cpp using Vec3D = std::array<__m128, 3>; __m128 scalar_product(Vec3D a, Vec3D b) { return _mm_add_ps(_mm_add_ps(_mm_mul_ps(a[0], b[0]), _mm_mul_ps(a[1], b[1])), _mm_mul_ps(a[2], b[2])); } ``` The above will neither scale to AVX, AVX-512, etc. nor is it portable to other SIMD ISAs. ## Build Requirements cmake >= 3.0 C++11 Compiler: * GCC >= 4.8.1 * clang >= 3.4 * ICC >= 18.0.5 * Visual Studio 2019 (64-bit target) ## Building and Installing Vc * Clone Vc and initialize Vc's git submodules: ```sh git clone https://github.com/VcDevel/Vc.git cd Vc git submodule update --init ``` * Create a build directory: ```sh $ mkdir build $ cd build ``` * Configure with cmake and add relevant options: ```sh $ cmake .. ``` Optionally, specify an installation directory: ```sh $ cmake -DCMAKE_INSTALL_PREFIX=/opt/Vc .. ``` Optionally, include building the unit tests: ```sh $ cmake -DBUILD_TESTING=ON .. ``` On Windows, if you have multiple versions of Visual Studio installed, you can select one: ```sh $ cmake -G "Visual Studio 16 2019" .. ``` See `cmake --help` for a list of possible generators. * Build and install: ```sh $ cmake --build . -j 16 $ cmake --install . # may require permissions ``` On Windows, you can also open `Vc.sln` in Visual Studio and build/install from the IDE. ## Documentation The documentation is generated via [doxygen](http://doxygen.org). You can build the documentation by running `doxygen` in the `doc` subdirectory. Alternatively, you can find nightly builds of the documentation at: * [1.4 branch](https://vcdevel.github.io/Vc-1.4/) * [1.4.4 release](https://vcdevel.github.io/Vc-1.4.4/) * [1.4.3 release](https://vcdevel.github.io/Vc-1.4.3/) * [1.4.2 release](https://vcdevel.github.io/Vc-1.4.2/) * [1.4.1 release](https://vcdevel.github.io/Vc-1.4.1/) * [1.4.0 release](https://vcdevel.github.io/Vc-1.4.0/) * [1.3 branch](https://vcdevel.github.io/Vc-1.3/) * [1.3.0 release](https://vcdevel.github.io/Vc-1.3.0/) * [1.2.0 release](https://vcdevel.github.io/Vc-1.2.0/) * [1.1.0 release](https://vcdevel.github.io/Vc-1.1.0/) * [0.7 branch](https://vcdevel.github.io/Vc-0.7/) ## Publications * [M. Kretz, "Extending C++ for Explicit Data-Parallel Programming via SIMD Vector Types", Goethe University Frankfurt, Dissertation, 2015.](http://publikationen.ub.uni-frankfurt.de/frontdoor/index/index/docId/38415) * [M. Kretz and V. Lindenstruth, "Vc: A C++ library for explicit vectorization", Software: Practice and Experience, 2011.](http://dx.doi.org/10.1002/spe.1149) * [M. Kretz, "Efficient Use of Multi- and Many-Core Systems with Vectorization and Multithreading", University of Heidelberg, 2009.](http://code.compeng.uni-frankfurt.de/attachments/13/Diplomarbeit.pdf) [Work on integrating the functionality of Vc in the C++ standard library.]( https://github.com/VcDevel/Vc/wiki/ISO-Standardization-of-the-Vector-classes) ## License Vc is released under the terms of the [3-clause BSD license](http://opensource.org/licenses/BSD-3-Clause). --- ## File: doc/README.md # Conky docs There are three YAML files that contain the documentation: - [`variables.yaml`](variables.yaml): Documents each object or variable - [`config_settings.yaml`](config_settings.yaml): Documents global configuration settings - [`lua.yaml`](lua.yaml): Documents Conky's Lua API The `desc` field within the docs can be formatted with Markdown; however, _do not_ include headings within `desc` fields, as that will break the man page output. In Markdown, headings begin with `#`. The supported documentation fields are: - `name`: the name of the thing - `desc`: a markdown-formatted description of the thing - `args`: optional list of arguments - `default`: an optional default value, if applicable ## Updating docs The man page is based on [`man.md.j2`](man.md.j2), which is a Jinja2 template. The generated markdown is used to generate a final man page using [`pandoc`](https://pandoc.org/). Generating the final man page is a two-step process: 1. Run `render.py` to process `man.md.j2`: ```console $ ./render.py man.md.j2 > man.md ``` 2. Run `pandoc` to convert the markdown into a man page: ```console $ pandoc --standalone -f markdown -t man man.md > conky.1 ``` These steps are also part of the CMake build, and can be executed by configuring the build with `-DBUILD_DOCS=ON`. When building the docs with CMake, target files are written to the CMake build directory, and not necessarily the same path as the source files.