 In this work we design two new types of primitives called short-lived zero-knowledge proofs and short-lived signatures. Imagine you sign something on a piece of paper with disappearing ink. Whatever you sign would vanish after some time. What's the cryptographic equivalent of this? In other words, what does it mean to make a digital signature vanish? One way to do this is to have the signature lose its soundness over time. Say Alice signs something at time zero. Up to time t, we want her signature to be sound. But after time t, the signature should no longer be convincing. This gives us a notion of deniability too. That is after time t, Alice could claim that anyone could have made this unsound signature without her private key. So how do we achieve this? We allow signatures to be forged after some time. Notice there's a forger here who can perform a slow computation that takes time t and finally produces a forgery. Alice's real signature and this forgery should be indistinguishable. And anyone should be able to create a forgery for any key and any message. All of this requires a notion of time. We don't have a global clock but we need some way to tell how fresh her signature is. That is if it was made within time t upon receiving the signature or not. And we do this using Beacons. We assume all parties in our protocols have access to a beacon that periodically emits randomness. Here in this diagram we have a beacon that emits 256 bits of randomness every delta time. Beacons have been constructed using randomness from stock prices, blockchain block hashes, and from distributed multi-party protocols like DRAN. In our paper we describe three applications of our new primitives. For short-lived signatures we use them in deniable messaging, emails, and in invalidating email leaks. Short-lived zero-knowledge proofs can be used in electronic voting systems to get an interesting property called receipt-freaness. We construct short-lived proofs and signatures by transforming generic NISIC and sigma protocols into their short-lived variations. In our paper we have four transformations for proofs and two more for signatures, and they each have different complexities and properties. Our constructions all use verifiable delay functions as a key tool. A VDF is a function that takes a fixed number of sequential steps to compute. But once this computation is done it's easy for other parties to verify that it was done correctly. These are the set eval and verify functions respectively. In our work we formalize the notion of re-randomizable VDFs, and we define and construct zero-knowledge VDFs, which are VDFs where y is intervealed, but the verifier is given a proof convincing them that the prover has indeed computed y or has knowledge of y. These variants of VDFs will give us interesting properties for our short-lived proofs and signatures. One such property is the notion of reusable forgability. Here forging something with a beacon value produces an extra advice string, and this advice string can help speed up further forgeries under that beacon. This enhances deniability as every beacon value now requires just one long computation that helps produce forgeries for all other keys and statements for that beacon value. When formalizing short-lived proofs we need a new notion of soundness which we call T-soundness. T-soundness stipulates that you should be able to extract a witness from a prover that produces proofs in time less than T since the beacon was emitted. But after time T has passed we lose this guarantee about witness extraction. Note that the time here starts when the beacon value is given, not when the input statement or message is designed. We implement our constructions using Weselowski VDFs using the RSA 2048 group. Our constructions are actually quite practical, adding just about half a kilobyte of size overhead to our Sigma proof versions. Our construction using ZK VDFs notably has reusable forgability and induces a fraction of a second overhead for the prover, 120 milliseconds here. We design more efficient constructions particular to signatures and implement them on RSA signatures to get similarly low overheads for prover time and the size of the signatures.