A snapshot object is a concurrent data structure that has numerous applications in concurrent programming. Snapshots can be used to record the state of the system, so they can provide solutions to problems where an action should be taken when the global state of the system satisfies some conditions. A snapshot object consists of m components, each storing a value from a given set. Processes can read/modify the state of the object by performing U P DAT E and SCAN operations. An U P DAT E operation gives processes the ability to change the value of a component, while the SCAN operation returns a "consistent" view of all the components. In most literature, two variants (in terms of the number active scanners) of snapshot objects are studied. The first one is the single-scanner snapshot object, where at most one SCAN operation is performed at any given time (whilst supporting many concurrent U P DAT E operations). The second one is the multi-scanner snapshot object that can support multi concurrent SCAN operations at any given time.In this work, we propose the λ-scanner snapshot, a variation of the snapshot object, which supports any fixed amount of 0 < λ ≤ n different SCAN operations being active at any given time. Whenever λ is equal to the number of processes n in the system, the λ-scanner object implements a multi-scanner object, while in case that λ is equal to 1, the λ-scanner object implements a single-scanner object. We present the λ−Snap snapshot object, a waitfree λ-scanner snapshot implementation that has a step complexity of O(λ) for U P DAT E operations and O(λm) for SCAN operations. The space complexity of λ − Snap is O(λm). λ − Snap provides a trade-off between the step/space complexity and the maximum number of SCAN operations that the system can afford to be active on any given point in time. The low space complexity that our implementations provide makes them more appealing in real system applications. Moreover, we provide a slightly modified version of the λ − Snap implementation, which is called partial λ − Snap, that is able to support dynamic partial scan operations. In such an object, processes can execute modified SCAN operations called P ART IAL SCAN that could obtain a part of the snapshot object avoiding to read the whole set of components.In this work, we first provide a simple single-scanner version of λ − Snap, which is called 1 − Snap. We provide 1 − Snap just for presentation purposes, since it is simpler than λ − Snap. The U P DAT E in 1 − Snap has a step complexity of O(1), while the SCAN has a step complexity of O(m). This implementation uses O(m) CAS registers.