nix-build-cache - Extends stdenv

  •        6

nix-build-cache extends stdenv.mkDerivation based builds with a distributed build cache. Many build tools produce intermediate files as part of a build, and if these intermediate files are present for subsequent build, steps of the build can be eliminated. nix-build-cache manages these files in a somewhat impure manner, to avoid the output hash changing. Essentially, these build cache files are purely optimisations and as such shouldn't impact the resulting output. nix-build-cache augments a build by adding some extra steps to preConfigure and preInstall.

https://github.com/ocharles/nix-build-cache

Tags
Implementation
License
Platform

   




Related Projects

nixpkgs - Nix Packages collection

  •    Nix

For pull-requests, please rebase onto nixpkgs master. NixOS Linux distribution source code is located inside nixos/ folder.

home-manager - Manage a user environment using Nix

  •    Nix

This project provides a basic system for managing a user environment using the Nix package manager together with the Nix libraries found in Nixpkgs. Before attempting to use Home Manager please read the warning below. In some cases Home Manager cannot detect whether it will overwrite a previous manual configuration. For example, the Gnome Terminal module will write to your dconf store and cannot tell whether a configuration that it is about to be overwrite was from a previous Home Manager generation or from manual configuration.

nix-docker - Provision Docker images using Nix

  •    Nix

Use NixOS configurations to provision Docker containers. The easy way to do this is to use Vagrant.

nixery - Container registry which transparently builds images using the Nix package manager

  •    Go

Nixery is a Docker-compatible container registry that is capable of transparently building and serving container images using Nix. Images are built on-demand based on the image name. Every package that the user intends to include in the image is specified as a path component of the image name.

w3-total-cache-fixed - A community driven build of W3 Total Cache

  •    PHP

This project is a community driven build of W3 Total Cache (W3TC) originally developed by @ftownes. The aim is to continuously incorporate fixes, improvements, and enhancements over the official Wordpress release of W3 Total Cache. For all changes by W3 Total Cache (Fixed) contributors (that were or not merged by W3 Total Cache official release), read the changelog.


nix - Nix, the purely functional package manager

  •    C++

Nix is a new take on package management that is fairly unique. Because of its purity aspects, a lot of issues found in traditional package managers don't appear with Nix. To find out more about the tool, usage and installation instructions, please read the manual, which is available on the Nix website at http://nixos.org/nix/manual.

AFCache - AFCache is an HTTP cache for iOS and OSX seeking towards full RFC2616 compliance

  •    Objective-C

AFCache is an HTTP disk cache for use on iPhone/iPad and OSX. It can be linked as a static library or as a framework. The cache was initially written because on iOS, NSURLCache ignores NSURLCacheStorageAllowed and instead treats it as NSURLCacheStorageAllowedInMemoryOnly which is pretty useless for a persistent cache. Build a fully RFC2616 compliant cache instead of doing simple time-based caching Status: Works for general use, some edge cases might not be compliant/implemented yet.

hard-source-webpack-plugin

  •    Javascript

HardSourceWebpackPlugin is a plugin for webpack to provide an intermediate caching step for modules. In order to see results, you'll need to run webpack twice with this plugin: the first build will take the normal amount of time. The second build will be signficantly faster. Install with npm install --save hard-source-webpack-plugin or yarn. And include the plugin in your webpack's plugins configuration.

KTVHTTPCache - A smart media cache framework.

  •    Objective-C

KTVHTTPCache is a smart media cache framework. It can cache HTTP request, very suitable for media resources. Run carthage update to build the framework and drag the built KTVHTTPCache.framework and KTVCocoaHTTPServer.framework into your Xcode project.

hnix - A Haskell re-implementation of the Nix expression language

  •    Nix

Haskell parser, evaluator and type checker for the Nix language. Nix is installed and in your $PATH. This is so that nix-store can be used for interacting with store paths, until hnix-store is ready.

nix - Rust friendly bindings to *nix APIs

  •    Rust

Nix seeks to provide friendly bindings to various *nix platform APIs (Linux, Darwin, ...). The goal is to not provide a 100% unified interface, but to unify what can be while still providing platform specific APIs. For many system APIs, Nix provides a safe alternative to the unsafe APIs exposed by the libc crate. This is done by wrapping the libc functionality with types/abstractions that enforce legal/safe usage.

static-binaries - Various *nix tools built as statically-linked binaries

  •    Shell

This repo contains a bunch of statically-linked binaries of various tools, along with the Dockerfiles / other build scripts that can be used to build them. I generally just create these as I need them - not all tools are available for every platform or architecture. Please file an issue if you want a new tool or a tool on a new platform. The nmap_centos5 binary isn't statically-linked; rather, it's built on CentOS5, so it "should" run on just about every modern version of Linux. Use this if something in the static binary doesn't work properly.

SharePoint Cache Refresh Framework

  •    

This project's aim is build a small and easy to use framework for SharePoint developers to be able to control cached objects across servers in a SharePoint Farm

Rome - A cache tool for Carthage

  •    Haskell

as a shared cache for frameworks built with Carthage. This will download Rome to the Pods/ folder during your next pod install execution and will allow you to invoke it via ${PODS_ROOT}/Rome/rome in your Script Build Phases.

haskell-nix - Nix and Haskell in production

  •    Nix

The emphasis of this guide is to be as robust as possible and gracefully handle writing Haskell projects at scale. Some of the suggestions in this guide might be overkill for a small Haskell project but are essential when managing multiple private Haskell projects across a team of developers. This guide is based partly on the Haskell section of the nixpkgs manual and partly on experience using Nix and Haskell in production at Awake Security.

lorri - Your project's nix-env

  •    Nix

lorri is a nix-shell replacement for project development. lorri is based around fast direnv integration for robust CLI and editor integration. The project is about experimenting with and improving the developer's experience with Nix. A particular focus is managing your project's external dependencies, editor integration, and quick feedback.

makepp

  •    C

GNU make compatible but reliable and simpler build tool

loadrunner - Simple, flexible and sane JavaScript loader and build tool for browsers.

  •    Javascript

Loadrunner is a JavaScript dependency manager. Loadrunner started off as my science project script loader and module system but its turned into a generic dependency manager that you can build on to manage any type of asynchronous dependency from CSS templates to DOM events to cache loading. It does however include build in support for loading regular JavaScript files, AMD modules and its own, more elegant (IMHO) flavour of modules.

miso - :ramen: A tasty Haskell front-end framework

  •    Haskell

Miso is a small "isomorphic" Haskell front-end framework for quickly building highly interactive single-page web applications. It features a virtual-dom, diffing / patching algorithm, attribute and property normalization, event delegation, event batching, SVG, Server-sent events, Websockets, type-safe servant-style routing and an extensible Subscription-based subsystem. Inspired by Elm, Redux and Bobril. Miso is pure by default, but side effects (like XHR) can be introduced into the system via the Effect data type. Miso makes heavy use of the GHCJS FFI and therefore has minimal dependencies. Miso can be considered a shallow embedded domain-specific language for modern web programming. To get started quickly building applications, we recommend using the stack or nix package managers. Obtaining GHCJS is required as a prerequisite. stack and nix make this process easy, if you're using cabal we assume you have obtained GHCJS by other means.